5634 lines
250 KiB
Python
5634 lines
250 KiB
Python
"""
|
|
Ce fichier permets de créer les inscription des stagiaires à une 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
|
|
import email_inscription_mgt as email_session
|
|
from flask import send_file
|
|
import re
|
|
from xhtml2pdf import pisa
|
|
import jinja2
|
|
import ftplib
|
|
import pysftp
|
|
import email_mgt as email_mgt
|
|
import lms_chamilo.mysy_lms as mys_lms
|
|
|
|
"""
|
|
Enregistrement d'un stagiaire
|
|
|
|
Voici les valeurs possibles du statut d'un stagiaire
|
|
# 0 ==> Preinscription
|
|
# 1 ==> Inscription validée
|
|
# 2 ==> Encours d'inscription. Ce statut est surtout utilisé quand on fait de inscription depuis le backoffice par un gestionnaire de formation.
|
|
# -1 ==> Inscription annulée
|
|
|
|
/!\ : Cette foncton est utilisé aussi bien en mode non-connecté qu'en mode connecté
|
|
il ne faut donc controler le token que s'il est fourni avec une valeur donnée
|
|
|
|
/!\ 2 : le 'partner_owner_recid' doit etre celui de la session de formation, EN AUCUN CAS CELUI DE LA PERSONNE CONNECTEE
|
|
|
|
"""
|
|
def AddStagiairetoClass(diction):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
'''
|
|
# 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 = ['nom', 'prenom', 'email', 'telephone', 'modefinancement', 'opco',
|
|
'class_internal_url', 'session_id', 'employeur', 'status', 'price',
|
|
'inscription_validation_date', 'token', 'client_rattachement_id',
|
|
'adresse', 'code_postal', 'ville', '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é")
|
|
return False, "Impossible de créer le stagiaire. Toutes les informations fournies ne sont pas valables"
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['nom', 'prenom', 'email', 'telephone', 'modefinancement',
|
|
'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 créer le stagiaire. La valeur '" + val + "' n'est pas presente dans liste"
|
|
|
|
mydata = {}
|
|
|
|
session_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
mydata['session_id'] = str(diction['session_id']).strip()
|
|
session_id = str(diction['session_id']).strip()
|
|
|
|
"""
|
|
Verififier l'existance et la valididé de la session
|
|
"""
|
|
my_session_data_qry = {"_id":ObjectId(str(session_id)), 'valide':'1' }
|
|
#print(" AddStagiairetoClass my_session_data_qry = ", my_session_data_qry)
|
|
|
|
my_session_data = MYSY_GV.dbname['session_formation'].find_one(my_session_data_qry)
|
|
if( my_session_data is None ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " L'identifiant de la session est invalide session_id = ", str(session_id))
|
|
return False, " L'identifiant de la session est invalide"
|
|
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = str(diction['token']).strip()
|
|
|
|
|
|
"""
|
|
Recuperation des info de la session de formation
|
|
"""
|
|
|
|
"""
|
|
update : 13/07/23 : gestion des prix
|
|
|
|
- par defaut si Le champ diction['price'] est rempli, alors on prend cette valeur.
|
|
- si cette valeur est vide ou inexistante, on va chercher le prix sur la session.
|
|
- Si aucun prix n'est mis sur la session, on va aller cherche le prix sur la formation.
|
|
|
|
|
|
"""
|
|
new_price = "-1" # 0 ==> par defaut
|
|
for tmp_val in MYSY_GV.dbname['session_formation'].find({"_id":ObjectId(str(session_id)), 'valide':'1' }):
|
|
mydata['date_du'] = tmp_val['date_debut']
|
|
mydata['date_au'] = tmp_val['date_fin']
|
|
mydata['partner_owner_recid'] = tmp_val['partner_owner_recid']
|
|
|
|
if ("prix_session" in tmp_val.keys()):
|
|
if tmp_val['prix_session']:
|
|
new_price = tmp_val['prix_session']
|
|
mydata['price'] = tmp_val['prix_session']
|
|
|
|
|
|
|
|
if ("nom" in diction.keys()):
|
|
if diction['nom']:
|
|
mydata['nom'] = str(diction['nom']).strip()
|
|
|
|
if ("prenom" in diction.keys()):
|
|
if diction['prenom']:
|
|
mydata['prenom'] = str(diction['prenom']).strip()
|
|
|
|
if ("employeur" in diction.keys()):
|
|
if diction['employeur']:
|
|
mydata['employeur'] = str(diction['employeur']).strip()
|
|
|
|
if ("telephone" in diction.keys()):
|
|
if diction['telephone']:
|
|
mydata['telephone'] = str(diction['telephone']).strip()
|
|
|
|
if ("client_rattachement_id" in diction.keys()):
|
|
if diction['client_rattachement_id']:
|
|
mydata['client_rattachement_id'] = diction['client_rattachement_id']
|
|
|
|
## Verifier l'existance du client de rattachement
|
|
local_client_retval_count = MYSY_GV.dbname['partner_client'].count_documents( {'_id': ObjectId(diction['client_rattachement_id']),
|
|
'valide': '1','locked': '0', 'partner_recid': str(my_session_data['partner_owner_recid'])})
|
|
|
|
if( local_client_retval_count != 1 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Le client de rattachement est invalide : local_client_retval_count = "+ str(local_client_retval_count))
|
|
return False, " Le client de rattachement est invalide "
|
|
|
|
|
|
|
|
if ("ville" in diction.keys()):
|
|
if diction['ville']:
|
|
mydata['ville'] = diction['ville']
|
|
|
|
if ("code_postal" in diction.keys()):
|
|
if diction['code_postal']:
|
|
mydata['code_postal'] = diction['code_postal']
|
|
|
|
if ("adresse" in diction.keys()):
|
|
if diction['adresse']:
|
|
mydata['adresse'] = diction['adresse']
|
|
|
|
|
|
if ("pays" in diction.keys()):
|
|
if diction['pays']:
|
|
mydata['pays'] = diction['pays']
|
|
|
|
|
|
if ("inscription_validation_date" in diction.keys()):
|
|
if diction['inscription_validation_date']:
|
|
mydata['inscription_validation_date'] = str(diction['inscription_validation_date']).strip()
|
|
|
|
if ("email" in diction.keys()):
|
|
if diction['email']:
|
|
mydata['email'] = str(diction['email']).strip()
|
|
regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b'
|
|
if (not re.fullmatch(regex, str(diction['email']) ) ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " l'adresse email "+str(diction['email'])+" est invalide")
|
|
return False, " l'adresse email -"+str(diction['email'])+"- est invalide"
|
|
|
|
|
|
if ("modefinancement" in diction.keys()):
|
|
if diction['modefinancement']:
|
|
mydata['modefinancement'] = str(diction['modefinancement']).strip()
|
|
|
|
if ("opco" in diction.keys()):
|
|
if diction['opco']:
|
|
mydata['opco'] = str(diction['opco']).strip()
|
|
|
|
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
mydata['class_internal_url'] = str(diction['class_internal_url']).strip()
|
|
|
|
|
|
mydata['date_update'] = datetime.now().strftime("%d/%m/%Y, %H:%M:%S")
|
|
|
|
new_status = "2" # 0 ==> par defaut Encours (Inscription en cours de creation, ici, on ne declenche aucun email)
|
|
if ("status" in diction.keys()):
|
|
if diction['status']:
|
|
new_status = str(diction['status']).strip()
|
|
if( new_status not in MYSY_GV.INSCRIPTION_STATUS):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le statut d'inscription : " + str(diction['status']) + " est invalide ")
|
|
return False, " Le statut d'inscription : " + str(diction['status']) + " est invalide "
|
|
|
|
|
|
mydata['status'] = str(new_status)
|
|
|
|
|
|
if ("price" in diction.keys()):
|
|
if diction['price']:
|
|
new_price = str(diction['price']).strip()
|
|
mydata['price'] = str(diction['price']).strip()
|
|
|
|
# Verification des prix. si new_price = "-1" cela veut dire qu'il n'a pas de prix dans le diction ni sur la session
|
|
# Alors on va chercher le prix (prix public sans reduction) sur la formation
|
|
if( new_price == "-1"):
|
|
local_class = MYSY_GV.dbname['myclass'].find_one({'internal_url':str(diction['class_internal_url']).strip(),
|
|
'valide':'1', 'locked':'0'})
|
|
|
|
if( 'price' in local_class.keys()):
|
|
mydata['price'] = str(local_class['price']).strip()
|
|
else:
|
|
mydata['price'] = '0'
|
|
|
|
|
|
#print(" #### mydata = " + str(mydata))
|
|
|
|
coll_inscription = MYSY_GV.dbname['inscription']
|
|
|
|
## Verification si cette adresse n'est pas deja inscrite à cette session
|
|
# print(" myquery pr demo_account = " + str(myquery))
|
|
qry_count = {'email':str(mydata['email']), 'session_id':str( mydata['session_id']), }
|
|
|
|
#print(" ### qry_count = ", qry_count)
|
|
tmp = coll_inscription.count_documents({'email':str(mydata['email']),
|
|
'session_id':str( mydata['session_id']),
|
|
})
|
|
|
|
if( tmp > 0 ) :
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - L'adresse email "+str(mydata['email'])+" est deja inscrite à la session du "
|
|
" "+str( mydata['session_id'])+ " ")
|
|
|
|
return False, "Impossible de créer le stagiaire. l'adresse email "+str(mydata['email'])\
|
|
+" est deja inscrite à cette session de formation "
|
|
|
|
|
|
"""
|
|
Un email ne pouvant s'inscrire qu'a une seule session_id; on fait un usert
|
|
"""
|
|
|
|
ret_val = MYSY_GV.dbname['inscription'].find_one_and_update(
|
|
{'session_id': str(mydata['session_id']), 'email': str(mydata['email']),},
|
|
{"$set": mydata},
|
|
return_document=ReturnDocument.AFTER,
|
|
upsert=True,
|
|
)
|
|
|
|
if (ret_val is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible d'ajouter la participant ")
|
|
return False, " Impossible d'ajouter la participant "
|
|
|
|
#ret_val = coll_inscription.insert_one(mydata)
|
|
|
|
Warning_message = ""
|
|
|
|
inserted_id = ret_val['_id']
|
|
|
|
"""
|
|
update du 25/08/23
|
|
On ne declenche l'envoie d'un email que l'inscription est soit :
|
|
- Preinscrit soit
|
|
- inscrit soit
|
|
- annulé.
|
|
|
|
Donc pas d'email si le statut est (2 => 'encours de creation'
|
|
On doit donner la possibilité a l'utilisateur de saisir une inscription avec un statut en cours de creation : 'creation'
|
|
"""
|
|
|
|
if( inserted_id ):
|
|
# On verifie que le statut de l'inscription n'est pas (2 : en cours) avant de declencher des envoies d'email
|
|
|
|
if( new_status != "2"):
|
|
# Le stagaire a bien ete inseré, on declenche l'envoi des emaisl
|
|
|
|
## Envoie de l'email de preinscription
|
|
mail_data = {}
|
|
mail_data['email'] = diction['email']
|
|
mail_data['class_internal_url'] = diction['class_internal_url']
|
|
mail_data['session_id'] = diction['session_id']
|
|
mail_data['inscription_id'] = ret_val['_id']
|
|
|
|
print(" ### l'inscription est ok, il faut declencher l'envoi des email a "+str(mail_data))
|
|
local_status, message = SendPre_InscriptionEmail(mail_data)
|
|
if( local_status is False):
|
|
mycommon.myprint(" WARNING : Impossible d'envoyer le mail de preinscriton à "+
|
|
str(inspect.stack()[0][3]) + " - l'adresse email " + str(
|
|
mydata['email']) + " pour la session " + str(mydata['session_id']) + " ")
|
|
|
|
Warning_message = " WARNING : Impossible d'envoyer le mail de preinscriton à "+ str(inspect.stack()[0][3]) + " - l'adresse email " + str( mydata['email']) + " pour la session " + str(mydata['session_id']) + " "
|
|
|
|
|
|
else:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - ret_val.inserted_id is null ")
|
|
return False, "Impossible de créer le stagiaire"
|
|
|
|
|
|
return True, " Le stagiaire à bien été créé. "+str(Warning_message)
|
|
|
|
|
|
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'ajouter le stagiaire"
|
|
|
|
"""
|
|
Mettre à jour les infomration d'un stgiaire
|
|
|
|
/!\ : on NE mets PAS à jour la session, juste les info du stagiaire
|
|
|
|
# status : 0 ==> Preinscription
|
|
# status : 1 ==> Inscription validée
|
|
# status : -1 ==> Inscription annulée
|
|
# status : 2 ==> Inscription encours de creation
|
|
|
|
/!\ Inscription sur le LMS :
|
|
Si la session de formation possede un code de formation lms 'lms_class_code'
|
|
|
|
Alors cela veut dire que c'est une formation qui est gérée avec le LMS de MYSY.
|
|
Donc l'inscription va generer :
|
|
1 - La creation du compte LMS participant
|
|
2 - L'inscription de l'utilisateur à la formation.
|
|
|
|
"""
|
|
def UpdateStagiairetoClass(diction):
|
|
try:
|
|
|
|
return_message = ""
|
|
field_list = ['token', 'email', 'nom', 'prenom', 'telephone', 'modefinancement', 'opco',
|
|
'status', 'class_internal_url', 'session_id', 'price', 'employeur', 'comment',
|
|
'_id', 'client_rattachement_id', 'adresse', 'code_postal', 'ville', '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 mettre à jour stagiaire. Toutes les informations fournies ne sont pas valables"
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'email', 'class_internal_url', 'session_id', '_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 mettre à jour stagiaire, Toutes les informations necessaires n'ont pas été fournies"
|
|
|
|
query_key = {}
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = str(diction['token']).strip()
|
|
#query_key['token'] = 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"
|
|
|
|
mydata = {}
|
|
user_nom = ""
|
|
|
|
|
|
myemail = ""
|
|
if ("email" in diction.keys()):
|
|
if diction['email']:
|
|
myemail = str(diction['email']).strip()
|
|
if( mycommon.isEmailValide(myemail)) :
|
|
mydata['email'] = str(diction['email']).strip()
|
|
else:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - l'adresse email "+str(myemail)+" n'est pas valide")
|
|
return False, "- l'adresse email "+str(myemail)+" n'est pas valide "
|
|
|
|
|
|
object_id = ""
|
|
if ("_id" in diction.keys()):
|
|
if diction['email']:
|
|
object_id = str(diction['_id']).strip()
|
|
query_key['_id'] = ObjectId (str(diction['_id']).strip())
|
|
|
|
myinternal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
myinternal_url = str(diction['class_internal_url']).strip()
|
|
#query_key['class_internal_url'] = str(diction['class_internal_url']).strip()
|
|
|
|
mysession_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
mysession_id = str(diction['session_id']).strip()
|
|
#query_key['session_id'] = str(diction['session_id']).strip()
|
|
|
|
|
|
|
|
partner_recid = mycommon.get_parnter_recid_from_token(mytoken)
|
|
if (partner_recid is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de mettre à jour le stagiaire ")
|
|
return False, "Impossible de mettre à jour le stagiaire "
|
|
|
|
|
|
|
|
""""
|
|
/!\ : update du 18/08/2023 : On va autoriser le changement le session de formation.
|
|
en effet il peut arriver qu'on souhaite deplacer la formation d'une personne à une autre session.
|
|
"""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
mysession_id = str(diction['session_id']).strip()
|
|
mydata['session_id'] = str(diction['session_id']).strip()
|
|
|
|
if ("nom" in diction.keys()):
|
|
if diction['nom']:
|
|
mydata['nom'] = str(diction['nom']).strip()
|
|
user_nom = str(diction['nom']).strip()
|
|
|
|
if ("price" in diction.keys()):
|
|
mydata['price'] = str(diction['price']).strip()
|
|
|
|
if ("employeur" in diction.keys()):
|
|
mydata['employeur'] = str(diction['employeur']).strip()
|
|
|
|
user_prenom = ""
|
|
if ("prenom" in diction.keys()):
|
|
mydata['prenom'] = str(diction['prenom']).strip()
|
|
user_prenom = str(diction['prenom']).strip()
|
|
|
|
if ("telephone" in diction.keys()):
|
|
mydata['telephone'] = str(diction['telephone']).strip()
|
|
|
|
if ("modefinancement" in diction.keys()):
|
|
mydata['modefinancement'] = str(diction['modefinancement']).strip()
|
|
|
|
if ("opco" in diction.keys()):
|
|
mydata['opco'] = str(diction['opco']).strip()
|
|
|
|
if ("price" in diction.keys()):
|
|
mydata['price'] = str(diction['price']).strip()
|
|
|
|
if ("adresse" in diction.keys()):
|
|
mydata['adresse'] = str(diction['adresse']).strip()
|
|
|
|
if ("code_postal" in diction.keys()):
|
|
mydata['code_postal'] = str(diction['code_postal']).strip()
|
|
|
|
if ("ville" in diction.keys()):
|
|
mydata['ville'] = str(diction['ville']).strip()
|
|
|
|
if ("pays" in diction.keys()):
|
|
mydata['pays'] = str(diction['pays']).strip()
|
|
|
|
new_status = ""
|
|
old_status = ""
|
|
if ("status" in diction.keys()):
|
|
if diction['status']:
|
|
mydata['status'] = str(diction['status']).strip()
|
|
new_status = str(diction['status']).strip()
|
|
|
|
# On stock le old_status avec la valeur de new_status.
|
|
# Cela permettra de comparer apres pour voir s'il y a un changement de statut.
|
|
old_status = str(diction['status']).strip()
|
|
|
|
if (new_status not in MYSY_GV.INSCRIPTION_STATUS):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le statut d'inscription : " + str(
|
|
diction['status']) + " est invalide ")
|
|
return False, " Le statut d'inscription : " + str(diction['status']) + " est invalide "
|
|
|
|
|
|
if ("comment" in diction.keys()):
|
|
mydata['comment'] = str(diction['comment']).strip()
|
|
|
|
|
|
if ("client_rattachement_id" in diction.keys()):
|
|
mydata['client_rattachement_id'] = str(diction['client_rattachement_id']).strip()
|
|
if(len(str(diction['client_rattachement_id']).strip()) > 0 ):
|
|
## Verifier l'existance du client de rattachement
|
|
local_client_retval_count = MYSY_GV.dbname['partner_client'].count_documents({'_id': ObjectId(diction['client_rattachement_id']),
|
|
'valide': '1', 'locked': '0', 'partner_recid': str(partner_recid)})
|
|
|
|
if (local_client_retval_count != 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Le client de rattachement est invalide : local_client_retval_count = "+str(local_client_retval_count))
|
|
return False, " Le client de rattachement est invalide "
|
|
|
|
|
|
# ici recup des infos de la session
|
|
local_query = {'_id': ObjectId(str(mysession_id)), 'valide': '1'}
|
|
print("### local_query = " + str(local_query))
|
|
|
|
local_tmp_session_count = MYSY_GV.dbname['session_formation'].count_documents(local_query)
|
|
if (local_tmp_session_count <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Aucune session de formation pour " + str(local_query))
|
|
return False, "Impossible de mettre à jour le stagiaire, Cette session de formation n'est pas valide "
|
|
|
|
if (local_tmp_session_count > 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Plusieurs sessions existent pour ce code sessions " + str(
|
|
local_query))
|
|
return False, "Impossible de mettre à jour le stagiaire, Cette session de formation n'est pas valide (2) "
|
|
|
|
local_tmp_session_data = MYSY_GV.dbname['session_formation'].find_one(local_query)
|
|
|
|
"""
|
|
update de 20/08/23 :
|
|
Vu qu'on autorise maintenant le changement de session, alors pour parer à une eventellement changement de sessio
|
|
pour une affectation a une session appartenant à une autre formation,
|
|
on va ecraser le 'class_internal_url' de la collection 'inscription' avec celui de la collection 'session_formation'
|
|
|
|
"""
|
|
mydata['class_internal_url'] = str(local_tmp_session_data['class_internal_url']).strip()
|
|
|
|
"""
|
|
Pour gerer la date de validation, differemment d'une simple mise à jour,
|
|
on récupérer le status actuellement en base, on verifie si le nouveau status != de status en base.
|
|
|
|
Si il y a changement de status alors c'est une date de changement de status.
|
|
"""
|
|
coll_inscription = MYSY_GV.dbname['inscription']
|
|
|
|
print(" #### query_key = ", query_key)
|
|
local_retval = coll_inscription.find_one(query_key)
|
|
|
|
|
|
if( local_retval is not None ):
|
|
if( "status" in local_retval.keys()):
|
|
|
|
# On recupere le statut stock en base dans 'old_status'
|
|
old_status = local_retval['status']
|
|
inscription_line_id = local_retval['_id']
|
|
|
|
|
|
if( new_status != old_status ):
|
|
# Il y a eu un changement de status
|
|
if( new_status == "1"):
|
|
mydata['inscription_validation_date'] = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
if (new_status == "-1"):
|
|
mydata['inscription_refuse_date'] = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
if (new_status == "2"):
|
|
mydata['inscription_preinscription_date'] = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
|
|
ret_val2 = coll_inscription.find_one_and_update(query_key,
|
|
{"$set": mydata},
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if (ret_val2 and ret_val2['_id']):
|
|
|
|
"""
|
|
- Si le status == 1; alors il s'agit d'une validation d'une inscription.
|
|
- Si le status == -1; alors il s'agit d'une refus d'une inscription.
|
|
- Si le status == 0; alors il s'agit d'une preinscription.
|
|
|
|
Du coup, il faut envoyer le mail de confirmation de l'inscription:
|
|
1 - recuperation des infos de la session
|
|
1 BIS - recuperation du title
|
|
2 - Envoie de l'email
|
|
"""
|
|
email_data = {}
|
|
email_data['nom'] = user_nom
|
|
email_data['prenom'] = user_prenom
|
|
email_data['email'] = myemail
|
|
|
|
if ("comment" in diction.keys()):
|
|
if diction['comment']:
|
|
email_data['comment'] = diction['comment']
|
|
|
|
if ("code_session" in local_tmp_session_data.keys()):
|
|
if local_tmp_session_data['code_session']:
|
|
email_data['code_session'] = local_tmp_session_data['code_session']
|
|
|
|
if ("date_debut" in local_tmp_session_data.keys()):
|
|
if local_tmp_session_data['date_debut']:
|
|
email_data['date_debut'] = str(local_tmp_session_data['date_debut'])[0:10]
|
|
|
|
if ("date_fin" in local_tmp_session_data.keys()):
|
|
if local_tmp_session_data['date_fin']:
|
|
email_data['date_fin'] = str(local_tmp_session_data['date_fin'])[0:10]
|
|
|
|
if ("adresse" in local_tmp_session_data.keys()):
|
|
if local_tmp_session_data['adresse']:
|
|
email_data['adresse'] = local_tmp_session_data['adresse']
|
|
|
|
if ("code_postal" in local_tmp_session_data.keys()):
|
|
if local_tmp_session_data['code_postal']:
|
|
email_data['code_postal'] = local_tmp_session_data['code_postal']
|
|
|
|
if ("ville" in local_tmp_session_data.keys()):
|
|
if local_tmp_session_data['ville']:
|
|
email_data['ville'] = local_tmp_session_data['ville']
|
|
|
|
if ("session_ondemande" in local_tmp_session_data.keys()):
|
|
if local_tmp_session_data['session_ondemande']:
|
|
email_data['session_ondemande'] = local_tmp_session_data['session_ondemande']
|
|
|
|
|
|
|
|
# ici recup du titre
|
|
lms_class_code = ""
|
|
for local_tmp_myclass in MYSY_GV.dbname['myclass'].find(
|
|
{'internal_url': str(myinternal_url)}):
|
|
|
|
local_title = ""
|
|
if ("title" in local_tmp_myclass.keys() and local_tmp_myclass['title']):
|
|
local_title = local_tmp_myclass['title']
|
|
email_data['title'] = local_title
|
|
|
|
|
|
if ("lms_class_code" in local_tmp_myclass.keys() ):
|
|
lms_class_code = local_tmp_myclass['lms_class_code']
|
|
|
|
print(" #### new_status / old_status / diction['status'] = ",new_status, old_status, str(diction['status']) )
|
|
if ( new_status != old_status and diction['status'] == "0" ):
|
|
mail_data = {}
|
|
mail_data['email'] = diction['email']
|
|
mail_data['class_internal_url'] = diction['class_internal_url']
|
|
mail_data['session_id'] = diction['session_id']
|
|
mail_data['inscription_id'] = diction['_id']
|
|
|
|
# Il s'agit d'envoyer le message de presinscription
|
|
|
|
local_status, local_message = SendPre_InscriptionEmail(mail_data)
|
|
if (local_status is False):
|
|
mycommon.myprint(" WARNING : Impossible d'envoyer le mail de preinscriton à " +
|
|
str(inspect.stack()[0][3]) + " - l'adresse email " + str(
|
|
mydata['email']) + " pour la session " + str(mydata['session_id']) + " ")
|
|
|
|
Warning_message = " WARNING : Impossible d'envoyer le mail de preinscriton à " + str(
|
|
inspect.stack()[0][3]) + " - l'adresse email " + str(
|
|
mydata['email']) + " pour la session " + str(mydata['session_id']) + " "
|
|
|
|
|
|
|
|
if (new_status != old_status and diction['status'] == "1" ):
|
|
# Il s'agit d'envoyer le message de confirmation d'une inscription
|
|
email_data['partner_owner_recid'] = str(partner_recid)
|
|
local_status, local_message = email_session.incription_training_confirmation_mail(email_data)
|
|
|
|
""""
|
|
Inscription sur le LMS :
|
|
Si la session de formation possede un code de formation lms 'lms_class_code'
|
|
|
|
Alors cela veut dire que c'est une formation qui est gérée avec le LMS de MYSY.
|
|
Donc l'inscription va generer :
|
|
1 - La creation du compte LMS participant
|
|
2 - L'inscription de l'utilisateur à la formation.
|
|
|
|
"""
|
|
if( lms_class_code.strip() != ""):
|
|
print(" ### Debut creation lms_class_code.strip() pour le code class ", lms_class_code)
|
|
new_diction = {}
|
|
new_diction['token'] = diction['token']
|
|
new_diction['lastname'] = user_nom
|
|
new_diction['firstname'] = user_prenom
|
|
new_diction['email'] = myemail
|
|
new_diction['password'] = secrets.token_urlsafe(6)
|
|
new_diction['locked'] = "0"
|
|
|
|
#split_mail_tab = str(myemail).split('@')
|
|
#new_diction['username'] = split_mail_tab[0]
|
|
|
|
new_diction['username'] = myemail
|
|
|
|
|
|
local_status, local_message, local_participant_lms_id = mys_lms.Create_MySy_LMS_Apprenant(new_diction)
|
|
|
|
if( local_status is False ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) +" WARNING : le compte LSM n'a pas été correctement crée")
|
|
return_message = return_message + " le compte LSM n'a pas été correctement crée. "
|
|
else:
|
|
# Mettre à jour la collection "inscription" en ajoutant local_participant_lms_id et et le mot de passe
|
|
print(" ### Mise à jour 'inscription' pour inscription_line_id = ", inscription_line_id,
|
|
" local_participant_lms_id = ", local_participant_lms_id, " str(new_diction['password'] ", str(new_diction['password']))
|
|
local_ret_val = MYSY_GV.dbname['inscription'].find_one_and_update({'_id':ObjectId(str(inscription_line_id))},
|
|
{"$set":{'lms_user_id':str(local_participant_lms_id),
|
|
'lms_pwd':str(new_diction['password']),
|
|
'lms_class_code':str(lms_class_code)}
|
|
},
|
|
upsert=False,
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
if (local_ret_val and local_ret_val['_id']):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Le compte LMS du participant a été correctement mis à jour : local_ret_val['_id'] = "+str( local_ret_val['_id']))
|
|
""""
|
|
A present, on va proceder à l'inscription à la formation
|
|
"""
|
|
print(" ### Debut de l'inscription au à la formation dans le LMS ")
|
|
new_diction = {}
|
|
new_diction['token'] = diction['token']
|
|
new_diction['user_lms_id'] = local_participant_lms_id
|
|
new_diction['course_code'] = lms_class_code
|
|
|
|
|
|
local_status2, local_message2 = mys_lms.Add_User_To_LMS_Class(new_diction)
|
|
if (local_status2 is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " WARNING : Impossbile de finaliser l'incription dans le LMS")
|
|
return_message = return_message + " Impossbile de finaliser l'incription dans le LMS. "
|
|
else:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " TOP, l'inscription dans le LMS a ete correctement faite")
|
|
|
|
else:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - WARNING : Impossible de mettre à jour le compte LMS ")
|
|
return_message = return_message + " Impossible de mettre à jour le compte LMS."
|
|
|
|
|
|
|
|
elif ( new_status != old_status and diction['status'] == "-1" ):
|
|
# Il s'agit d'envoyer le message de refus d'une inscription
|
|
local_status, local_message = email_session.incription_training_refused_mail(email_data)
|
|
|
|
|
|
|
|
mycommon.myprint(" Les données du stagiaire ont été correctement mise à jour")
|
|
if( len(str(return_message)) > 5):
|
|
return True, "Les données du stagiaire ont été correctement mise à jour. WARNING : "+return_message
|
|
|
|
return True, "Les données du stagiaire ont été correctement mise à jour"
|
|
|
|
|
|
else:
|
|
mycommon.myprint(" Impossible de mettre à jour les données du stagiaire 1")
|
|
return False, "Impossible de mettre à jour les données du stagiaire "
|
|
|
|
|
|
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 mettre à jour les informations du stagiaire"
|
|
|
|
|
|
|
|
"""
|
|
Recuperation d'un stagiaire
|
|
"""
|
|
def GetStagiaire(diction):
|
|
try:
|
|
field_list = ['nom', 'adr_street', 'adr_city']
|
|
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 récupérer le stagiaire. Toutes les informations fournies ne sont pas valables"
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['nom', 'email', 'pwd', ]
|
|
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 le stagiaire, Toutes les informations necessaires n'ont pas été fournies"
|
|
|
|
|
|
return True
|
|
|
|
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 le stagiaire"
|
|
|
|
|
|
"""
|
|
Recuperation de liste des stagiaire d'une formation
|
|
# status : 0 ==> Preinscription
|
|
# status : 1 ==> Inscription validée
|
|
# status : -1 ==> Inscription annulée
|
|
"""
|
|
def GetAllClassStagiaire(diction):
|
|
try:
|
|
field_list = ['token', 'class_internal_url', 'session_id', 'status']
|
|
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, "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']
|
|
|
|
status = ""
|
|
if ("status" in diction.keys()):
|
|
if diction['status']:
|
|
status = diction['status']
|
|
|
|
|
|
## Recuperation de toutes les stagiaire rattaché à cette session
|
|
coll_session = MYSY_GV.dbname['inscription']
|
|
myquery = {}
|
|
myquery['session_id'] = session_id
|
|
myquery['class_internal_url'] = class_internal_url
|
|
|
|
if(len(status) > 0 ):
|
|
myquery['status'] = status
|
|
|
|
|
|
RetObject = []
|
|
val_tmp = 0
|
|
|
|
#print(" #### myquery 01111 = "+str(myquery))
|
|
|
|
|
|
for retval in coll_session.find(myquery):
|
|
val_tmp = val_tmp + 1
|
|
user = retval
|
|
user['id'] = str(val_tmp)
|
|
RetObject.append(mycommon.JSONEncoder().encode(user))
|
|
|
|
return True, RetObject
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de récupérer la liste des stagiaires de la formation"
|
|
|
|
|
|
"""
|
|
Cette fonction envoie l'email de confirmation d'une inscription a une formation.
|
|
|
|
Ceci est mis en "mode function" pour permettre aux utilisateur de renvoyer
|
|
autant de fois que souhaité la confirmation d'inscription
|
|
"""
|
|
def SendInscriptionConfirmation(diction):
|
|
try:
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'email', '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 d'envoyer la confirmation d'inscription"
|
|
|
|
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 le recid du partenaire")
|
|
return False, " Impossible d'envoyer le mail de confirmation"
|
|
|
|
|
|
data_mail = {}
|
|
# 1 - Recuperation des données de la formation
|
|
local_class = MYSY_GV.dbname['myclass'].find({'internal_url':str(diction['class_internal_url'])})
|
|
data_mail['title'] = local_class[0]['title']
|
|
|
|
|
|
# 2 - Recuperation des données de l'inscription
|
|
local_inscription = MYSY_GV.dbname['inscription'].find({'session_id':str(diction['session_id']),
|
|
'email':str(diction['email'])})
|
|
local_nom = ""
|
|
if ("nom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['nom']:
|
|
local_nom = local_inscription[0]['nom']
|
|
data_mail['nom'] = local_nom
|
|
|
|
local_prenom = ""
|
|
if ("prenom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['prenom']:
|
|
local_prenom = local_inscription[0]['prenom']
|
|
data_mail['prenom'] = local_prenom
|
|
|
|
data_mail['email'] = local_inscription[0]['email']
|
|
|
|
# 3 - Recuperations des info de la session (a distance, formateur, etc)
|
|
local_info_session = MYSY_GV.dbname['session_formation'].find({'_id': ObjectId(str(diction['session_id'])),
|
|
'class_internal_url': str(
|
|
diction['class_internal_url']),
|
|
'valide': '1'})
|
|
|
|
if (local_info_session is None):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - impossible d'envoyer le mail d'inscription. la session " + str(
|
|
diction['session_id']) + " est introuvable ")
|
|
return False, " impossible d'envoyer le mail d'inscription. la session " + str(
|
|
diction['session_id']) + " est introuvable "
|
|
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_info_session[0].keys()):
|
|
if local_info_session[0]['date_du']:
|
|
date_du = local_info_session[0]['date_du']
|
|
data_mail['date_du'] = str(date_du)[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_info_session[0].keys()):
|
|
if local_info_session[0]['date_au']:
|
|
date_au = local_info_session[0]['date_au']
|
|
data_mail['date_au'] = str(date_au)[0:10]
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_info_session[0].keys()):
|
|
if local_info_session[0]['adresse']:
|
|
adresse = local_info_session[0]['adresse']
|
|
data_mail['adresse'] = adresse
|
|
|
|
session_ondemande = ""
|
|
if ("session_ondemande" in local_info_session[0].keys()):
|
|
if local_info_session[0]['session_ondemande']:
|
|
session_ondemande = local_info_session[0]['session_ondemande']
|
|
data_mail['session_ondemande'] = session_ondemande
|
|
|
|
code_session = ""
|
|
if ("code_session" in local_info_session[0].keys()):
|
|
if local_info_session[0]['code_session']:
|
|
code_session = local_info_session[0]['code_session']
|
|
data_mail['code_session'] = code_session
|
|
|
|
data_mail['partner_owner_recid'] = str(partner_recid)
|
|
local_status, local_message = email_session.incription_training_confirmation_mail(data_mail)
|
|
|
|
return local_status, "La confirmation d'inscription a bien ete envoyé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 d'envoyer la confirmation d'inscription"
|
|
|
|
|
|
"""
|
|
Cette fonction envoie les pre-inscritpions
|
|
"""
|
|
def SendPre_InscriptionEmail(diction):
|
|
try:
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
|
|
field_list_obligatoire = [ 'email', 'session_id', 'inscription_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 d'envoyer la pre-inscription "
|
|
|
|
|
|
data_mail = {}
|
|
|
|
|
|
|
|
# 2 - Recuperation des données de l'inscription
|
|
local_session = MYSY_GV.dbname['inscription'].find({'session_id':str(diction['session_id']),
|
|
'email':str(diction['email']),
|
|
'_id':ObjectId(str(diction['inscription_id']))})
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Impossible de récupérer les information de la session de formation")
|
|
return False, "Impossible de récupérer les information de la session de formation "
|
|
|
|
data_mail['nom'] = local_session[0]['nom']
|
|
data_mail['prenom'] = local_session[0]['prenom']
|
|
data_mail['email'] = local_session[0]['email']
|
|
data_mail['partner_owner_recid'] = local_session[0]['partner_owner_recid']
|
|
|
|
|
|
if ("employeur" in local_session[0].keys()):
|
|
if local_session[0]['employeur']:
|
|
data_mail['employeur'] = local_session[0]['employeur']
|
|
|
|
if ("telephone" in local_session[0].keys()):
|
|
if local_session[0]['telephone']:
|
|
data_mail['telephone'] = local_session[0]['telephone']
|
|
|
|
# 1 - Recuperation des données de la formation
|
|
local_class = MYSY_GV.dbname['myclass'].find({'internal_url': str(local_session[0]['class_internal_url']),
|
|
'partner_owner_recid':str(local_session[0]['partner_owner_recid']),
|
|
'valide':'1', 'locked':'0'})
|
|
|
|
if( local_class is None):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Impossible de récupérer les information de la formation")
|
|
return False, "Impossible de récupérer les information de la formation "
|
|
|
|
|
|
data_mail['title'] = local_class[0]['title']
|
|
partner_recid = local_class[0]['partner_owner_recid']
|
|
|
|
# 1-BIS : Recuperation des donnees de l'editeur de la formation
|
|
local_partner = MYSY_GV.dbname['partnair_account'].find_one({'recid': str(partner_recid)})
|
|
if( local_partner is None):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Impossible de récupérer les information du partenaire")
|
|
return False, "Impossible de récupérer les information du partenaire "
|
|
|
|
|
|
data_mail['partner_mail'] = local_partner['email']
|
|
|
|
|
|
#3 - Recuperations des info de la session (a distance, formateur, etc)
|
|
local_info_session = MYSY_GV.dbname['session_formation'].find_one({'_id': ObjectId(str(diction['session_id'])), 'valide':'1'})
|
|
|
|
|
|
|
|
if( local_info_session is None):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - impossible d'envoyer le mail de presinscription. la session "+str(diction['session_id'])+" est introuvable ")
|
|
return False, " impossible d'envoyer le mail de presinscription. la session "+str(diction['session_id'])+" est introuvable "
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_info_session.keys()):
|
|
if local_info_session['code_postal']:
|
|
code_postal = local_info_session['code_postal']
|
|
data_mail['code_postal'] = code_postal
|
|
|
|
code_session = ""
|
|
if ("code_session" in local_info_session.keys()):
|
|
if local_info_session['code_session']:
|
|
code_session = local_info_session['code_session']
|
|
data_mail['code_session'] = code_postal
|
|
|
|
|
|
date_debut = ""
|
|
if ("date_debut" in local_info_session.keys()):
|
|
if local_info_session['date_debut']:
|
|
date_debut = str(local_info_session['date_debut'])[0:10]
|
|
data_mail['date_du'] = date_debut
|
|
|
|
date_fin = ""
|
|
if ("date_fin" in local_info_session.keys()):
|
|
if local_info_session['date_fin']:
|
|
date_fin = str(local_info_session['date_fin'])[0:10]
|
|
data_mail['date_au'] = date_fin
|
|
|
|
formateur = ""
|
|
if ("formateur" in local_info_session.keys()):
|
|
if local_info_session['formateur']:
|
|
formateur = local_info_session['formateur']
|
|
data_mail['formateur'] = formateur
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in local_info_session.keys()):
|
|
if local_info_session['distantiel']:
|
|
distantiel = local_info_session['distantiel']
|
|
data_mail['distantiel'] = distantiel
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in local_info_session.keys()):
|
|
if local_info_session['presentiel']:
|
|
presentiel = local_info_session['presentiel']
|
|
data_mail['presentiel'] = presentiel
|
|
|
|
ville = ""
|
|
if ("ville" in local_info_session.keys()):
|
|
if local_info_session['ville']:
|
|
ville = local_info_session['ville']
|
|
data_mail['ville'] = ville
|
|
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_info_session.keys()):
|
|
if local_info_session['adresse']:
|
|
adresse = local_info_session['adresse']
|
|
data_mail['adresse'] = adresse
|
|
|
|
session_ondemande = ""
|
|
if ("session_ondemande" in local_info_session.keys()):
|
|
if local_info_session['session_ondemande']:
|
|
session_ondemande = local_info_session['session_ondemande']
|
|
data_mail['session_ondemande'] = session_ondemande
|
|
|
|
|
|
#print(" Pre_incription_training_confirmation_mail DATA = ",data_mail )
|
|
|
|
# Envoi de l'email de confirmation au demandeur de la formation
|
|
local_status, local_message = email_session.Pre_incription_training_confirmation_mail(data_mail)
|
|
|
|
|
|
# Envoi de l'email de notification au formateur
|
|
local_status, local_message = email_session.Notification_partner_Pre_incription_mail(data_mail)
|
|
|
|
return local_status, "La confirmation de la pre-inscription a bien ete envoyé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 d'envoyer la confirmation d'inscription"
|
|
|
|
|
|
"""
|
|
Cette fonction retour en CSV la liste
|
|
des personnes inscrites à une session de formation
|
|
"""
|
|
def DownloadParticipantsList(diction):
|
|
try:
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = field_list = ['token', 'session_id', '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 generer la liste des participants. les informations sont incompletes"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = diction['token']
|
|
|
|
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 generer la liste des participants. les informations sont incompletes"
|
|
|
|
|
|
session_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
session_id = diction['session_id']
|
|
|
|
internal_url = ""
|
|
if ("internal_url" in diction.keys()):
|
|
if diction['internal_url']:
|
|
internal_url = diction['internal_url']
|
|
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one({'code_session':session_id, 'class_internal_url':internal_url})
|
|
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Cette de formation n'a pas d'informations detaillées ")
|
|
return False, " Cette session de formation n'a pas d'informations detaillées "
|
|
|
|
# Recuperation des données de la formation
|
|
local_formation = MYSY_GV.dbname['myclass'].find_one({'internal_url':str(internal_url)})
|
|
if (local_formation is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Cette de formation n'a pas d'informations detaillées (2) ")
|
|
return False, " Cette de formation n'a pas d'informations detaillées (2) "
|
|
|
|
## Recuperation de toutes les stagiaire rattaché à cette session
|
|
coll_session = MYSY_GV.dbname['inscription']
|
|
myquery = {}
|
|
myquery['session_id'] = session_id
|
|
myquery['class_internal_url'] = internal_url
|
|
|
|
|
|
RetObject = []
|
|
|
|
for retval in coll_session.find(myquery, { 'session_id':0}):
|
|
|
|
local_data = {}
|
|
local_data['titre'] = local_formation['title']
|
|
local_data['debut_session'] = local_session ['date_debut']
|
|
local_data['fin_session'] = local_session['date_fin']
|
|
|
|
local_formateur = ""
|
|
if ("formateur" in local_session.keys()):
|
|
if local_session['formateur']:
|
|
local_formateur = local_session['formateur']
|
|
local_data['formateur'] = local_formateur
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in local_session.keys()):
|
|
if local_session['presentiel']:
|
|
presentiel = local_session['presentiel']
|
|
local_data['presentiel'] = presentiel
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in local_session.keys()):
|
|
if local_session['distantiel']:
|
|
distantiel = local_session['distantiel']
|
|
local_data['distantiel'] = distantiel
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_session.keys()):
|
|
if local_session['adresse']:
|
|
adresse = local_session['adresse']
|
|
local_data['adresse'] = adresse
|
|
|
|
ville = ""
|
|
if ("ville" in local_session.keys()):
|
|
if local_session['ville']:
|
|
ville = local_session['ville']
|
|
local_data['ville'] = ville
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_session.keys()):
|
|
if local_session['code_postal']:
|
|
code_postal = local_session['code_postal']
|
|
local_data['code_postal'] = code_postal
|
|
|
|
prix_session = ""
|
|
if ("prix_session" in local_session.keys()):
|
|
if local_session['prix_session']:
|
|
prix_session = local_session['prix_session']
|
|
local_data['prix_session'] = prix_session
|
|
|
|
nb_participant = ""
|
|
if ("nb_participant" in local_session.keys()):
|
|
if local_session['nb_participant']:
|
|
nb_participant = local_session['nb_participant']
|
|
local_data['nb_participants'] = nb_participant
|
|
|
|
|
|
|
|
local_data['prenom'] = retval['prenom']
|
|
local_data['nom'] = retval['nom']
|
|
local_data['email'] = retval['email']
|
|
local_data['telephone'] = retval['telephone']
|
|
local_data['date_inscription'] = str(retval['_id'].generation_time.strftime("%m/%d/%Y, %H:%M"))
|
|
|
|
|
|
employeur = ""
|
|
if ("employeur" in retval.keys()):
|
|
if (retval['employeur']):
|
|
employeur = retval['employeur']
|
|
local_data['employeur'] = employeur
|
|
|
|
financement = ""
|
|
if ("modefinancement" in retval.keys()):
|
|
if (retval['modefinancement']):
|
|
financement = retval['modefinancement']
|
|
local_data['financement'] = financement
|
|
|
|
opco = ""
|
|
if ("opco" in retval.keys()):
|
|
if (retval['opco']):
|
|
opco = retval['opco']
|
|
local_data['opco'] = opco
|
|
|
|
if '_id' in local_data:
|
|
del local_data['_id']
|
|
|
|
if( retval['status'] == "1"):
|
|
local_data['status'] = "inscrit"
|
|
|
|
elif (retval['status'] == "0"):
|
|
local_data['status'] = "en attente"
|
|
|
|
elif (retval['status'] == "-1"):
|
|
local_data['status'] = "refusé"
|
|
|
|
if ("inscription_validation_date" in retval.keys()):
|
|
if( retval['inscription_validation_date']):
|
|
local_data['inscription_validation_date'] = str(retval['inscription_validation_date'])[0:10]
|
|
|
|
if ("inscription_refuse_date" in retval.keys()):
|
|
if (retval['inscription_refuse_date']):
|
|
local_data['inscription_refuse_date'] = str(retval['inscription_refuse_date'])[0:10]
|
|
|
|
RetObject.append(local_data)
|
|
|
|
|
|
"""
|
|
/!\ : Quand il n'y a pas encore de stagaire, alors le grid : RetObject : est vide car la boucle precedent est vide
|
|
Donc on retourne juste les infos de la session
|
|
"""
|
|
|
|
print(" ### len(RetObject) = ", len(RetObject) , " RetObject = ", RetObject )
|
|
if(len(RetObject) <= 0 ):
|
|
local_data = {}
|
|
local_data['titre_formation'] = local_formation['title']
|
|
local_data['debut_session'] = local_session['date_debut']
|
|
local_data['fin_session'] = local_session['date_fin']
|
|
|
|
local_formateur = ""
|
|
if ("formateur" in local_session.keys()):
|
|
if local_session['formateur']:
|
|
local_formateur = local_session['formateur']
|
|
local_data['formateur'] = local_formateur
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in local_session.keys()):
|
|
if local_session['presentiel']:
|
|
local_formateur = local_session['presentiel']
|
|
local_data['presentiel'] = presentiel
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in local_session.keys()):
|
|
if local_session['distantiel']:
|
|
distantiel = local_session['distantiel']
|
|
local_data['distantiel'] = distantiel
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_session.keys()):
|
|
if local_session['adresse']:
|
|
adresse = local_session['adresse']
|
|
local_data['adresse'] = adresse
|
|
|
|
ville = ""
|
|
if ("ville" in local_session.keys()):
|
|
if local_session['ville']:
|
|
ville = local_session['ville']
|
|
local_data['ville'] = ville
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_session.keys()):
|
|
if local_session['code_postal']:
|
|
code_postal = local_session['code_postal']
|
|
local_data['code_postal'] = code_postal
|
|
|
|
prix_session = ""
|
|
if ("prix_session" in local_session.keys()):
|
|
if local_session['prix_session']:
|
|
prix_session = local_session['prix_session']
|
|
local_data['prix_session'] = prix_session
|
|
|
|
nb_participant = ""
|
|
if ("nb_participant" in local_session.keys()):
|
|
if local_session['nb_participant']:
|
|
nb_participant = local_session['nb_participant']
|
|
local_data['nb_participants'] = nb_participant
|
|
|
|
local_data['nb_inscrit'] = "0"
|
|
|
|
RetObject.append(local_data)
|
|
|
|
# Expand the cursor and construct the DataFrame
|
|
df = pd.DataFrame(list(RetObject))
|
|
|
|
file_name_tmp = mycommon.create_token_urlsafe()
|
|
file_name = ''.join(char for char in file_name_tmp if char.isalnum())
|
|
|
|
#print("#### filename = "+str(file_name))
|
|
|
|
df.to_excel(MYSY_GV.TEMPORARY_DIRECTORY+"/"+str(file_name)+".xlsx", index=False)
|
|
if os.path.exists(MYSY_GV.TEMPORARY_DIRECTORY+"/"+str(file_name)+".xlsx"):
|
|
path = MYSY_GV.TEMPORARY_DIRECTORY+"/"+str(file_name)+".xlsx"
|
|
return True, send_file(path, as_attachment=True)
|
|
else:
|
|
return False, False
|
|
|
|
|
|
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'envoyer la confirmation d'inscription"
|
|
|
|
|
|
"""
|
|
Cette fonction imprime au formation csv la liste des evaluations d'une formation
|
|
"""
|
|
def DownloadEvaluationList(diction):
|
|
try:
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'session_id', '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 generer la liste des participants. les informations sont incompletes"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = diction['token']
|
|
|
|
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 generer la liste des participants. les informations sont incompletes"
|
|
|
|
|
|
session_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
session_id = diction['session_id']
|
|
|
|
internal_url = ""
|
|
if ("internal_url" in diction.keys()):
|
|
if diction['internal_url']:
|
|
internal_url = diction['internal_url']
|
|
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one({'code_session':session_id, 'class_internal_url':internal_url})
|
|
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Cette de formation n'a pas d'informations detaillées ")
|
|
return False, " Cette session de formation n'a pas d'informations detaillées "
|
|
|
|
# Recuperation des données de la formation
|
|
local_formation = MYSY_GV.dbname['myclass'].find_one({'internal_url':str(internal_url)})
|
|
if (local_formation is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Cette de formation n'a pas d'informations detaillées (2) ")
|
|
return False, " Cette de formation n'a pas d'informations detaillées (2) "
|
|
|
|
## Recuperation de toutes les stagiaire rattaché à cette session
|
|
coll_session = MYSY_GV.dbname['inscription']
|
|
myquery = {}
|
|
myquery['session_id'] = session_id
|
|
myquery['class_internal_url'] = internal_url
|
|
myquery['status'] = "1"
|
|
|
|
|
|
RetObject = []
|
|
|
|
for retval in coll_session.find(myquery, { 'session_id':0}):
|
|
|
|
local_data = {}
|
|
local_data['titre'] = local_formation['title']
|
|
local_data['debut_session'] = local_session ['date_debut']
|
|
local_data['fin_session'] = local_session['date_fin']
|
|
|
|
local_formateur = ""
|
|
if ("formateur" in local_session.keys()):
|
|
if local_session['formateur']:
|
|
local_formateur = local_session['formateur']
|
|
local_data['formateur'] = local_formateur
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in local_session.keys()):
|
|
if local_session['presentiel']:
|
|
presentiel = local_session['presentiel']
|
|
local_data['presentiel'] = presentiel
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in local_session.keys()):
|
|
if local_session['distantiel']:
|
|
distantiel = local_session['distantiel']
|
|
local_data['distantiel'] = distantiel
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_session.keys()):
|
|
if local_session['adresse']:
|
|
adresse = local_session['adresse']
|
|
local_data['adresse'] = adresse
|
|
|
|
ville = ""
|
|
if ("ville" in local_session.keys()):
|
|
if local_session['ville']:
|
|
ville = local_session['ville']
|
|
local_data['ville'] = ville
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_session.keys()):
|
|
if local_session['code_postal']:
|
|
code_postal = local_session['code_postal']
|
|
local_data['code_postal'] = code_postal
|
|
|
|
|
|
|
|
local_data['prenom'] = retval['prenom']
|
|
local_data['nom'] = retval['nom']
|
|
local_data['email'] = retval['email']
|
|
local_data['telephone'] = retval['telephone']
|
|
local_data['date_inscription'] = str(retval['_id'].generation_time.strftime("%m/%d/%Y, %H:%M"))
|
|
|
|
eval_date = ""
|
|
if ("eval_date" in retval.keys()):
|
|
eval_date = retval['eval_date']
|
|
local_data['evaluation_date'] = str(eval_date)[0:10]
|
|
|
|
eval_note = ""
|
|
if ("eval_note" in retval.keys()):
|
|
eval_note = retval['eval_note']
|
|
local_data['evaluation_globale'] = eval_note
|
|
|
|
eval_pedagogie = ""
|
|
if ("eval_pedagogie" in retval.keys()):
|
|
eval_pedagogie = retval['eval_pedagogie']
|
|
local_data['evaluation_pedagogie'] = eval_pedagogie
|
|
|
|
eval_eval = ""
|
|
if ("eval_eval" in retval.keys()):
|
|
eval_eval = retval['eval_eval']
|
|
local_data['evaluation_commentaire'] = mycommon.cleanhtml(str(eval_eval))
|
|
|
|
|
|
if ("inscription_validation_date" in retval.keys()):
|
|
if( retval['inscription_validation_date']):
|
|
local_data['inscription_validation_date'] = str(retval['inscription_validation_date'])[0:10]
|
|
|
|
|
|
RetObject.append(local_data)
|
|
|
|
|
|
"""
|
|
/!\ : Quand il n'y a pas encore de stagaire, alors le grid : RetObject : est vide car la boucle precedent est vide
|
|
Donc on retourne juste les infos de la session
|
|
"""
|
|
|
|
print(" ### len(RetObject) = ", len(RetObject) , " RetObject = ", RetObject )
|
|
if(len(RetObject) <= 0 ):
|
|
local_data = {}
|
|
local_data['titre_formation'] = local_formation['title']
|
|
local_data['debut_session'] = local_session['date_debut']
|
|
local_data['fin_session'] = local_session['date_fin']
|
|
|
|
local_formateur = ""
|
|
if ("formateur" in local_session.keys()):
|
|
if local_session['formateur']:
|
|
local_formateur = local_session['formateur']
|
|
local_data['formateur'] = local_formateur
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in local_session.keys()):
|
|
if local_session['presentiel']:
|
|
local_formateur = local_session['presentiel']
|
|
local_data['presentiel'] = presentiel
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in local_session.keys()):
|
|
if local_session['distantiel']:
|
|
distantiel = local_session['distantiel']
|
|
local_data['distantiel'] = distantiel
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_session.keys()):
|
|
if local_session['adresse']:
|
|
adresse = local_session['adresse']
|
|
local_data['adresse'] = adresse
|
|
|
|
ville = ""
|
|
if ("ville" in local_session.keys()):
|
|
if local_session['ville']:
|
|
ville = local_session['ville']
|
|
local_data['ville'] = ville
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_session.keys()):
|
|
if local_session['code_postal']:
|
|
code_postal = local_session['code_postal']
|
|
local_data['code_postal'] = code_postal
|
|
|
|
prix_session = ""
|
|
if ("prix_session" in local_session.keys()):
|
|
if local_session['prix_session']:
|
|
prix_session = local_session['prix_session']
|
|
local_data['prix_session'] = prix_session
|
|
|
|
nb_participant = ""
|
|
if ("nb_participant" in local_session.keys()):
|
|
if local_session['nb_participant']:
|
|
nb_participant = local_session['nb_participant']
|
|
local_data['nb_participants'] = nb_participant
|
|
|
|
local_data['nb_inscrit'] = "0"
|
|
|
|
RetObject.append(local_data)
|
|
|
|
# Expand the cursor and construct the DataFrame
|
|
df = pd.DataFrame(list(RetObject))
|
|
|
|
file_name_tmp = mycommon.create_token_urlsafe()
|
|
file_name = ''.join(char for char in file_name_tmp if char.isalnum())
|
|
|
|
#print("#### filename = "+str(file_name))
|
|
|
|
df.to_excel(MYSY_GV.TEMPORARY_DIRECTORY+"/"+str(file_name)+".xlsx", index=False)
|
|
if os.path.exists(MYSY_GV.TEMPORARY_DIRECTORY+"/"+str(file_name)+".xlsx"):
|
|
path = MYSY_GV.TEMPORARY_DIRECTORY+"/"+str(file_name)+".xlsx"
|
|
return True, send_file(path, as_attachment=True)
|
|
else:
|
|
return False, False
|
|
|
|
|
|
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'envoyer la confirmation d'inscription"
|
|
|
|
|
|
|
|
""" Import des inscriptions en masse
|
|
Avec l'import d'un fichier csv
|
|
"""
|
|
def AddStagiairetoClass_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', 'session_id', '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 participants annulée")
|
|
return False, " Verifier votre API, Toutes les informations techniques ne sont pas fournies"
|
|
|
|
'''
|
|
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', 'session_id', '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, " Verifier votre API, Toutes les informations techniques ne sont pas fournies"
|
|
|
|
my_token = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
my_token = diction['token']
|
|
|
|
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 participants ")
|
|
return False, " Les information de connexion sont incorrectes. Impossible d'importer la liste des participants"
|
|
|
|
# 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()):
|
|
if diction['session_id']:
|
|
session_id = diction['session_id']
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
class_internal_url = diction['class_internal_url']
|
|
|
|
|
|
# Verification de l'existance de la session
|
|
## Verification de l'existance de session et recuperation du "code_session"
|
|
session_count = MYSY_GV.dbname['session_formation'].count_documents(
|
|
{'class_internal_url': str(class_internal_url), 'valide': '1',
|
|
'_id': ObjectId(str(session_id)), 'partner_owner_recid': str(partner_recid)})
|
|
|
|
if (session_count <= 0):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " -" + str(session_id) + " : ' Cette session n'est pas valide ")
|
|
return False, " Code de la session de formation n'est pas valide "
|
|
|
|
if (session_count > 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " -" + str(session_id) + " : ' Cette session existe en double ")
|
|
return False, " Les données de la session de formation sont incohérentes "
|
|
|
|
session_data = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'class_internal_url': str(class_internal_url), 'valide': '1',
|
|
'_id': ObjectId(str(session_id)), 'partner_owner_recid': str(partner_recid)})
|
|
|
|
if( "code_session" not in session_data.keys() ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Cette session de formation n'a pas de code_session ")
|
|
return False, " Cette session de formation n'a pas de code_session "
|
|
|
|
|
|
code_session = session_data['code_session']
|
|
|
|
# Verification de l'existance de la formation (class_internal_url)
|
|
tmp_count = MYSY_GV.dbname['myclass'].count_documents({'internal_url': str(class_internal_url), 'valide': '1',
|
|
'locked':'0', 'partner_owner_recid':str(partner_recid)})
|
|
|
|
# logging.info(" TMP = "+str(tmp))
|
|
if (tmp_count <= 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(class_internal_url) + " : ' Cette formation n'est pas valide ")
|
|
return False, " Cette formation n'est pas valide "
|
|
|
|
MyClass_Data = MYSY_GV.dbname['myclass'].find_one({'internal_url': str(class_internal_url), 'valide': '1',
|
|
'locked': '0',
|
|
'partner_owner_recid': str(partner_recid)})
|
|
|
|
if( "external_code" not in MyClass_Data.keys()):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " -" + str(class_internal_url) + " : ' Cette formation n'est pas valide (2)")
|
|
return False, " Cette formation n'est pas valide (2)"
|
|
|
|
MyClass_external_code = MyClass_Data['external_code']
|
|
|
|
|
|
status, saved_file = mycommon.Upload_Save_CSV_File(file, Folder)
|
|
if (status == False):
|
|
mycommon.myprint("Impossible de récupérer correctement le fichier à importer")
|
|
return False, "Impossible d'importer la liste des participants, 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_AddStagiairetoClass_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 = ['formation_code_externe', 'code_session', 'prenom', 'nom', 'employeur',
|
|
'telephone', 'email', 'modefinancement','opco', 'status', 'prix', 'adresse', 'code_postal', 'ville',
|
|
'pays', 'client_rattachement_email', 'client_rattachement_nom']
|
|
|
|
|
|
# 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 = ['prenom', 'nom', 'email', 'modefinancement', 'status', 'prix']
|
|
|
|
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 session.
|
|
session_data = MYSY_GV.dbname['session_formation'].find_one({'formation_session_id':str(session_id)})
|
|
if( session_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"
|
|
|
|
#print(" #### session_data = ",session_data)
|
|
"""
|
|
x = range(0, total_rows)
|
|
for n in x:
|
|
mydata = {}
|
|
mydata['prenom'] = str(df['prenom'].values[n])
|
|
mydata['nom'] = str(df['nom'].values[n])
|
|
mydata['employeur'] = str(df['employeur'].values[n])
|
|
mydata['telephone'] = str(df['telephone'].values[n])
|
|
mydata['email'] = str(df['email'].values[n])
|
|
regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b'
|
|
if (not re.fullmatch(regex, str(df['email'].values[n]))):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " l'adresse email " + str(df['email'].values[n]) + " est invalide")
|
|
return False, " l'adresse email -" + str(df['email'].values[n]) + "- est invalide"
|
|
|
|
|
|
mydata['session_id'] = str(session_data['_id'])
|
|
mydata['token'] = str(my_token)
|
|
|
|
modefinancement = ""
|
|
if ("modefinancement" in df.keys()):
|
|
if (str(df['modefinancement'].values[n])):
|
|
modefinancement = str(df['modefinancement'].values[n])
|
|
mydata['modefinancement'] = modefinancement
|
|
|
|
formation_code_externe = ""
|
|
if ("formation_code_externe" in df.keys()):
|
|
if (str(df['formation_code_externe'].values[n])):
|
|
formation_code_externe = str(df['formation_code_externe'].values[n]).strip()
|
|
|
|
if( str(formation_code_externe).lower() != str(MyClass_external_code).lower()):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Le code externe de la formation" + str(df['formation_code_externe'].values[n]) + " ne correspond pas la formation en cours")
|
|
return False, " Le code externe de la formation" + str(df['formation_code_externe'].values[n]) + " ne correspond pas la formation en cours"
|
|
|
|
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()
|
|
|
|
if (str(local_code_session).lower() != str(code_session).lower()):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Le code session de la formation" + str(
|
|
df['code_session'].values[n]) + " ne correspond pas au code de la session en cours")
|
|
return False, " Le code externer de la formation" + str(
|
|
df['code_session'].values[n]) + " ne correspond pas au code de la session en cours"
|
|
|
|
opco = ""
|
|
if ("opco" in df.keys()):
|
|
if (str(df['opco'].values[n])):
|
|
opco = str(df['opco'].values[n])
|
|
mydata['opco'] = opco
|
|
|
|
adresse = ""
|
|
if ("adresse" in df.keys()):
|
|
if (str(df['adresse'].values[n])):
|
|
adresse = str(df['adresse'].values[n])
|
|
mydata['adresse'] = adresse
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in df.keys()):
|
|
if (str(df['code_postal'].values[n])):
|
|
code_postal = str(df['code_postal'].values[n])
|
|
|
|
if ("." in str(code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
code_postal = str(code_postal).split(".")[0]
|
|
elif ("." in str(code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
code_postal = str(code_postal).split(",")[0]
|
|
else:
|
|
code_postal = str(code_postal)
|
|
|
|
mydata['code_postal'] = code_postal
|
|
|
|
ville = ""
|
|
if ("ville" in df.keys()):
|
|
if (str(df['ville'].values[n])):
|
|
ville = str(df['ville'].values[n])
|
|
mydata['ville'] = ville
|
|
|
|
pays = ""
|
|
if ("pays" in df.keys()):
|
|
if (str(df['pays'].values[n])):
|
|
pays = str(df['pays'].values[n])
|
|
mydata['pays'] = pays
|
|
|
|
|
|
""""
|
|
Gestion du client de rattachement/
|
|
Avec l'email et le nom, on va aller récupérer l'_id du client
|
|
"""
|
|
client_rattachement_email = ""
|
|
if ("client_rattachement_email" in df.keys()):
|
|
if (str(df['client_rattachement_email'].values[n]) and str(df['client_rattachement_email'].values[n]) != "nan" ):
|
|
client_rattachement_email = str(df['client_rattachement_email'].values[n])
|
|
|
|
|
|
client_rattachement_nom = ""
|
|
if ("client_rattachement_nom" in df.keys() and str(df['client_rattachement_nom'].values[n]) != "nan"):
|
|
if (str(df['client_rattachement_nom'].values[n])):
|
|
client_rattachement_nom = str(df['client_rattachement_nom'].values[n])
|
|
|
|
if( client_rattachement_email and client_rattachement_nom ):
|
|
local_client_retval_qry = {'email':str(client_rattachement_email), 'nom':str(client_rattachement_nom), 'valide':'1',
|
|
'locked':'0', 'partner_recid' :str(partner_recid)}
|
|
|
|
local_client_retval_count = MYSY_GV.dbname['partner_client'].count_documents(local_client_retval_qry)
|
|
|
|
if( local_client_retval_count > 1 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) +"Ligne : "+str(n) +". Plusieurs clients correspondent aux critère de nom :"+str(client_rattachement_nom)+" et email : "+str(client_rattachement_email))
|
|
return False, "Ligne : "+str(n) +". Plusieurs clients correspondent aux critère de nom :"+str(client_rattachement_nom)+" et email : "+str(client_rattachement_email)
|
|
|
|
if (local_client_retval_count < 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : "+str(n) +". Aucun client ne repond aux critères de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email))
|
|
return False, "Ligne : "+str(n) +". Aucun client ne repond aux critères de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email)
|
|
|
|
local_client_retval_data = MYSY_GV.dbname['partner_client'].find_one(local_client_retval_qry)
|
|
if( local_client_retval_data is not None ):
|
|
mydata['client_rattachement_id'] = local_client_retval_data['_id']
|
|
|
|
status = str(df['status'].values[n]).strip()
|
|
status = str(mycommon.tryInt(status))
|
|
|
|
if (str(status) != "0" and str(status) != "1" and str(status) != "2"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'status' de ligne " + str(
|
|
n) + " est incorrecte. Valeurs acceptées : 0,1,2")
|
|
return False, " Le champ status de la ligne " + str(n) + " est incorrecte. Valeurs acceptées : 0,1,2"
|
|
|
|
mydata['status'] = str(df['status'].values[n]).strip()
|
|
if (status == "1"):
|
|
mydata['inscription_validation_date'] = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
|
|
|
|
mydata['class_internal_url'] = str(class_internal_url)
|
|
|
|
|
|
local_price = str(df['prix'].values[n]).strip()
|
|
local_status, new_price = mycommon.IsFloat(local_price)
|
|
if( local_status is False ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][ 3]) + " Le champ 'prix' de ligne " + str( n) + " est incorrecte.")
|
|
return False, " Le champ prix de la ligne " + str(n) + " est incorrecte. "
|
|
|
|
mydata['price'] = local_price
|
|
|
|
|
|
clean_dict = {k: mydata[k] for k in mydata if ( str(mydata[k]) != "nan") }
|
|
|
|
print( "#### clean_dict ", clean_dict)
|
|
status, retval = AddStagiairetoClass(clean_dict)
|
|
|
|
if( status is False ):
|
|
return status, retval
|
|
|
|
print(str(total_rows)+" participants ont été inserés")
|
|
|
|
return True, str(total_rows)+" participants ont été inserées / Mises à jour"
|
|
|
|
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 participants en masse "
|
|
|
|
|
|
"""
|
|
Controle du fichier à importer avant import
|
|
"""
|
|
|
|
def Controle_AddStagiairetoClass_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', 'session_id', '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 participants annulée")
|
|
return False, " Verifier votre API, Toutes les informations techniques ne sont pas fournies"
|
|
|
|
'''
|
|
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', 'session_id', '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, " Verifier votre API, Toutes les informations techniques ne sont pas fournies"
|
|
|
|
my_token = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
my_token = diction['token']
|
|
|
|
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 participants ")
|
|
return False, " Les information de connexion sont incorrectes. Impossible d'importer la liste des participants"
|
|
|
|
# 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()):
|
|
if diction['session_id']:
|
|
session_id = diction['session_id']
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
class_internal_url = diction['class_internal_url']
|
|
|
|
# Verification de l'existance de la session
|
|
## Verification de l'existance de session et recuperation du "code_session"
|
|
session_count = MYSY_GV.dbname['session_formation'].count_documents(
|
|
{'class_internal_url': str(class_internal_url), 'valide': '1',
|
|
'_id': ObjectId(str(session_id)), 'partner_owner_recid': str(partner_recid)})
|
|
|
|
if (session_count <= 0):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " -" + str(session_id) + " : ' Cette session n'est pas valide ")
|
|
return False, " Code de la session de formation n'est pas valide "
|
|
|
|
if (session_count > 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " -" + str(session_id) + " : ' Cette session existe en double ")
|
|
return False, " Les données de la session de formation sont incohérentes "
|
|
|
|
session_data = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'class_internal_url': str(class_internal_url), 'valide': '1',
|
|
'_id': ObjectId(str(session_id)), 'partner_owner_recid': str(partner_recid)})
|
|
|
|
if ("code_session" not in session_data.keys()):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - Cette session de formation n'a pas de code_session ")
|
|
return False, " Cette session de formation n'a pas de code_session "
|
|
|
|
code_session = session_data['code_session']
|
|
|
|
# Verification de l'existance de la formation (class_internal_url)
|
|
tmp_count = MYSY_GV.dbname['myclass'].count_documents({'internal_url': str(class_internal_url), 'valide': '1',
|
|
'locked': '0',
|
|
'partner_owner_recid': str(partner_recid)})
|
|
|
|
# logging.info(" TMP = "+str(tmp))
|
|
if (tmp_count <= 0):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " -" + str(class_internal_url) + " : ' Cette formation n'est pas valide ")
|
|
return False, " Cette formation n'est pas valide "
|
|
|
|
MyClass_Data = MYSY_GV.dbname['myclass'].find_one({'internal_url': str(class_internal_url), 'valide': '1',
|
|
'locked': '0',
|
|
'partner_owner_recid': str(partner_recid)})
|
|
|
|
if ("external_code" not in MyClass_Data.keys()):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " -" + str(
|
|
class_internal_url) + " : ' Cette formation n'est pas valide (2)")
|
|
return False, " Cette formation n'est pas valide (2)"
|
|
|
|
MyClass_external_code = MyClass_Data['external_code']
|
|
|
|
|
|
# " 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 = ['formation_code_externe', 'code_session', 'prenom', 'nom', 'employeur',
|
|
'telephone', 'email', 'modefinancement', 'opco', 'status', 'prix', 'adresse', 'code_postal',
|
|
'ville',
|
|
'pays', 'client_rattachement_email', 'client_rattachement_nom']
|
|
|
|
# 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 = ['prenom', 'nom', 'email', 'modefinancement', 'status', 'prix']
|
|
|
|
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 session.
|
|
session_data = MYSY_GV.dbname['session_formation'].find_one({'formation_session_id':str(session_id)})
|
|
if( session_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"
|
|
|
|
#print(" #### session_data = ",session_data)
|
|
"""
|
|
x = range(0, total_rows)
|
|
for n in x:
|
|
mydata = {}
|
|
mydata['prenom'] = str(df['prenom'].values[n])
|
|
mydata['nom'] = str(df['nom'].values[n])
|
|
mydata['employeur'] = str(df['employeur'].values[n])
|
|
mydata['telephone'] = str(df['telephone'].values[n])
|
|
mydata['email'] = str(df['email'].values[n])
|
|
regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b'
|
|
if (not re.fullmatch(regex, str(df['email'].values[n]))):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " l'adresse email " + str(df['email'].values[n]) + " est invalide")
|
|
return False, " l'adresse email -" + str(df['email'].values[n]) + "- est invalide"
|
|
|
|
mydata['session_id'] = str(session_data['_id'])
|
|
mydata['token'] = str(my_token)
|
|
|
|
modefinancement = ""
|
|
if ("modefinancement" in df.keys()):
|
|
if (str(df['modefinancement'].values[n])):
|
|
modefinancement = str(df['modefinancement'].values[n])
|
|
mydata['modefinancement'] = modefinancement
|
|
|
|
formation_code_externe = ""
|
|
if ("formation_code_externe" in df.keys()):
|
|
if (str(df['formation_code_externe'].values[n])):
|
|
formation_code_externe = str(df['formation_code_externe'].values[n]).strip()
|
|
|
|
if (str(formation_code_externe).lower() != str(MyClass_external_code).lower()):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Le code externe de la formation" + str(
|
|
df['formation_code_externe'].values[
|
|
n]) + " ne correspond pas la formation en cours")
|
|
return False, " Le code externe de la formation" + str(
|
|
df['formation_code_externe'].values[n]) + " ne correspond pas la formation en cours"
|
|
|
|
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()
|
|
|
|
if (str(local_code_session).lower() != str(code_session).lower()):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Le code session de la formation" + str(
|
|
df['code_session'].values[n]) + " ne correspond pas au code de la session en cours")
|
|
return False, " Le code externer de la formation" + str(
|
|
df['code_session'].values[n]) + " ne correspond pas au code de la session en cours"
|
|
|
|
opco = ""
|
|
if ("opco" in df.keys()):
|
|
if (str(df['opco'].values[n])):
|
|
opco = str(df['opco'].values[n])
|
|
mydata['opco'] = opco
|
|
|
|
adresse = ""
|
|
if ("adresse" in df.keys()):
|
|
if (str(df['adresse'].values[n])):
|
|
adresse = str(df['adresse'].values[n])
|
|
mydata['adresse'] = adresse
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in df.keys()):
|
|
if (str(df['code_postal'].values[n])):
|
|
code_postal = str(df['code_postal'].values[n]).strip()
|
|
|
|
if ("." in str(code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
code_postal = str(code_postal).split(".")[0]
|
|
elif ("." in str(code_postal)):
|
|
# /!\ : l'utilisateur envoie un code poster au format entier, plutot que string.
|
|
code_postal = str(code_postal).split(",")[0]
|
|
else:
|
|
code_postal = str(code_postal)
|
|
|
|
mydata['code_postal'] = code_postal
|
|
|
|
|
|
|
|
ville = ""
|
|
if ("ville" in df.keys()):
|
|
if (str(df['ville'].values[n])):
|
|
ville = str(df['ville'].values[n])
|
|
mydata['ville'] = ville
|
|
|
|
pays = ""
|
|
if ("pays" in df.keys()):
|
|
if (str(df['pays'].values[n])):
|
|
pays = str(df['pays'].values[n])
|
|
mydata['pays'] = pays
|
|
|
|
""""
|
|
Gestion du client de rattachement/
|
|
Avec l'email et le nom, on va aller récupérer l'_id du client
|
|
"""
|
|
client_rattachement_email = ""
|
|
if ("client_rattachement_email" in df.keys()):
|
|
if (str(df['client_rattachement_email'].values[n]) and str(
|
|
df['client_rattachement_email'].values[n]) != "nan"):
|
|
client_rattachement_email = str(df['client_rattachement_email'].values[n])
|
|
|
|
client_rattachement_nom = ""
|
|
if ("client_rattachement_nom" in df.keys() and str(df['client_rattachement_nom'].values[n]) != "nan"):
|
|
if (str(df['client_rattachement_nom'].values[n])):
|
|
client_rattachement_nom = str(df['client_rattachement_nom'].values[n])
|
|
|
|
if (client_rattachement_email and client_rattachement_nom):
|
|
local_client_retval_qry = {'email': str(client_rattachement_email),
|
|
'nom': str(client_rattachement_nom), 'valide': '1',
|
|
'locked': '0', 'partner_recid': str(partner_recid)}
|
|
|
|
local_client_retval_count = MYSY_GV.dbname['partner_client'].count_documents(
|
|
local_client_retval_qry)
|
|
|
|
if (local_client_retval_count > 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : " + str(
|
|
n) + ". Plusieurs clients correspondent aux critère de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email))
|
|
return False, "Ligne : " + str(
|
|
n) + ". Plusieurs clients correspondent aux critère de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email)
|
|
|
|
if (local_client_retval_count < 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : " + str(
|
|
n) + ". Aucun client ne repond aux critères de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email))
|
|
return False, "Ligne : " + str(n) + ". Aucun client ne repond aux critères de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email)
|
|
|
|
local_client_retval_data = MYSY_GV.dbname['partner_client'].find_one(local_client_retval_qry)
|
|
if (local_client_retval_data is not None):
|
|
mydata['client_rattachement_id'] = local_client_retval_data['_id']
|
|
|
|
|
|
status = str(df['status'].values[n]).strip()
|
|
status = str(mycommon.tryInt(status))
|
|
|
|
|
|
if (str(status) != "0" and str(status) != "1" and str(status) != "2"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'status' de ligne " + str(
|
|
n) + " est incorrecte. Valeurs acceptées : 0,1,2")
|
|
return False, " Le champ status de la ligne " + str(
|
|
n) + " est incorrecte. Valeurs acceptées : 0,1,2"
|
|
|
|
mydata['status'] = status
|
|
|
|
|
|
if (str(status).strip() == "1"):
|
|
mydata['inscription_validation_date'] = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
mydata['class_internal_url'] = str(class_internal_url)
|
|
|
|
local_price = str(df['prix'].values[n]).strip()
|
|
local_status, new_price = mycommon.IsFloat(local_price)
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'prix' de ligne " + str(n) + " est incorrecte.")
|
|
return False, " Le champ prix de la ligne " + str(n) + " est incorrecte. "
|
|
|
|
mydata['price'] = local_price
|
|
|
|
## Verifier que le stagiaire n'est pas deja inscrit à cette formation.
|
|
qry_count = {'email': str(mydata['email']), 'session_id': str(session_id), 'partner_owner_recid':str(partner_recid) }
|
|
qry_count_result = MYSY_GV.dbname['inscription'].count_documents(qry_count)
|
|
|
|
if( qry_count_result > 0 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Ligne " + str(n) + " : L'adresse email "+str()+" est déjà inscrite à la session :"+str(code_session)+". ")
|
|
return False, " Ligne " + str(n) + " : L'adresse email "+str(mydata['email'])+" est déjà inscrite à la session de formation :"+str(code_session)+". "
|
|
|
|
|
|
|
|
return True, str(total_rows) + " participants lus dans le fichier excel"
|
|
|
|
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 "
|
|
|
|
|
|
"""
|
|
Cette fonction permet d'importer un fichier excel pour les stagiaire de plusieurs session, plusieurs formations
|
|
/!\ : Controle session : on va utiliser les colonne : formation code externe et le code de la session
|
|
/!\ : controle du client : on va utiliser le mail et le nom du client pour voir si ca concorde.
|
|
|
|
update du 21/08/23 :
|
|
Pour eviter les imports partiels du fichier, on va créer une fonction qui va faire les controles.
|
|
Si cette fonction est ok, alors on lance la fonction d'import.
|
|
|
|
Elle fera a peu pret les meme controle qui existe dans la fonction d'import actuelle.
|
|
|
|
"""
|
|
def AddStagiairetoClass_mass_for_many_session(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 participants annulée")
|
|
return False, " Verifier votre API"
|
|
|
|
'''
|
|
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, " Verifier votre API, Toutes les informations techniques ne sont pas fournies"
|
|
|
|
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"
|
|
|
|
|
|
|
|
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 participants ")
|
|
return False, " Les information de connexion sont incorrectes. Impossible d'importer la liste des participants"
|
|
|
|
|
|
|
|
|
|
status, saved_file = mycommon.Upload_Save_CSV_File(file, Folder)
|
|
if (status == False):
|
|
mycommon.myprint("Impossible de récupérer correctement le fichier à importer")
|
|
return False, "Impossible d'importer la liste des participants, le nom du fichier est incorrect "
|
|
|
|
#" Lecture du fichier "
|
|
#print(" Lecture du fichier : "+saved_file)
|
|
nb_line = 0
|
|
|
|
""""
|
|
update du 21/08/23 : Controle de l'integrité du fichier
|
|
"""
|
|
local_controle_status, local_controle_message = Controle_AddStagiairetoClass_mass_for_many_session(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 = ['formation_code_externe', 'code_session', 'prenom', 'nom', 'employeur',
|
|
'telephone', 'email', 'modefinancement', 'opco', 'status', 'prix', 'adresse', 'code_postal',
|
|
'ville', 'pays', 'client_rattachement_email', 'client_rattachement_nom']
|
|
|
|
|
|
# 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 = ['prenom', 'nom', 'email', 'modefinancement', 'status', 'prix']
|
|
|
|
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 session.
|
|
session_data = MYSY_GV.dbname['session_formation'].find_one({'formation_session_id':str(session_id)})
|
|
if( session_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"
|
|
|
|
#print(" #### session_data = ",session_data)
|
|
"""
|
|
x = range(0, total_rows)
|
|
for n in x:
|
|
mydata = {}
|
|
class_external_code = str(df['formation_code_externe'].values[n])
|
|
#mydata['code_session'] = str(df['code_session'].values[n])
|
|
mydata['prenom'] = str(df['prenom'].values[n])
|
|
mydata['nom'] = str(df['nom'].values[n])
|
|
mydata['employeur'] = str(df['employeur'].values[n])
|
|
mydata['telephone'] = str(df['telephone'].values[n])
|
|
mydata['email'] = str(df['email'].values[n])
|
|
regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b'
|
|
if (not re.fullmatch(regex, str(df['email'].values[n]))):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " l'adresse email " + str(df['email'].values[n]) + " est invalide")
|
|
return False, " l'adresse email -" + str(df['email'].values[n]) + "- est invalide"
|
|
|
|
mydata['token'] = str(my_token)
|
|
|
|
"""
|
|
Recuperation de l'internal url de la formation a partir de la cle
|
|
- formation code externe
|
|
- partner_owner_recid
|
|
"""
|
|
qry = {'external_code':str(class_external_code), 'valide':'1', 'locked':'0', 'partner_owner_recid':str(partner_recid)}
|
|
print(" ### qry = ", qry)
|
|
myclass_data_count = MYSY_GV.dbname['myclass'].count_documents({'external_code':str(class_external_code), 'valide':'1', 'locked':'0',
|
|
'partner_owner_recid':str(partner_recid)})
|
|
|
|
if( myclass_data_count != 1 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : " + str(
|
|
n + 2) + ": Le code externe de la formation et le code de la session ne correspondent pas .")
|
|
return False, "Ligne : " + str(
|
|
n + 2) + ": Le code externe de la formation et le code de la session ne correspondent pas."
|
|
|
|
|
|
myclass_data = MYSY_GV.dbname['myclass'].find_one({'external_code':str(class_external_code), 'valide':'1', 'locked':'0',
|
|
'partner_owner_recid':str(partner_recid)})
|
|
|
|
mysession_count_qry = {'class_internal_url': str(myclass_data['internal_url']), 'valide': '1',
|
|
'partner_owner_recid': str(partner_recid), 'code_session':str(df['code_session'].values[n]) }
|
|
|
|
print(" ### mysession_count_qry = ", qry)
|
|
|
|
mysession_count = MYSY_GV.dbname['session_formation'].count_documents(mysession_count_qry)
|
|
|
|
if( mysession_count != 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : " + str(
|
|
n + 2) + ": Le code externe de la formation et le code de la session ne correspondent pas (2).")
|
|
return False, "Ligne : " + str(
|
|
n + 2) + ": Le code externe de la formation et le code de la session ne correspondent pas (2)."
|
|
|
|
mysession_data = MYSY_GV.dbname['session_formation'].find_one(mysession_count_qry)
|
|
|
|
|
|
|
|
mydata['session_id'] = str(mysession_data['_id'])
|
|
mydata['class_internal_url'] = str(mysession_data['class_internal_url'])
|
|
"""
|
|
Recuperation de l''_id' de la session à partir de la clé
|
|
- formation code externe
|
|
- code_session
|
|
- partner_owner_recid
|
|
"""
|
|
|
|
"""
|
|
On verifie que le code de le session et le l'external class code correspondent.
|
|
En gros : que la formation en question a bien une session du meme code
|
|
"""
|
|
|
|
|
|
"""check_class_session_query = [{'$match': {'code_session':str(df['code_session'].values[n])}},
|
|
{'$lookup':
|
|
{
|
|
'from': 'myclass',
|
|
'localField': 'class_internal_url',
|
|
'foreignField': 'internal_url',
|
|
'pipeline': [{'$match': {'external_code':str(df['formation_code_externe'].values[n])}},
|
|
{'$project': {'title': 1, }}],
|
|
'as': 'myclass_collection'
|
|
}
|
|
}
|
|
]
|
|
|
|
print(" ##### myquery GetSessionFormation = " + str(check_class_session_query))
|
|
|
|
real_class_internal_url = ""
|
|
|
|
for check_class_session_retval in MYSY_GV.dbname['session_formation'].aggregate(check_class_session_query):
|
|
if ('myclass_collection' in check_class_session_retval.keys() and len(check_class_session_retval['myclass_collection']) > 0):
|
|
real_class_internal_url = check_class_session_retval['class_internal_url']
|
|
|
|
if( str(real_class_internal_url) == ""):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : " + str(
|
|
n+2) + ": Le code externe de la formation et le code de la session ne correspondent pas .")
|
|
return False, "Ligne : " + str(n+2) + ": Le code externe de la formation et le code de la session ne correspondent pas."
|
|
"""
|
|
|
|
|
|
|
|
|
|
modefinancement = ""
|
|
if ("modefinancement" in df.keys()):
|
|
if (str(df['modefinancement'].values[n])):
|
|
modefinancement = str(df['modefinancement'].values[n])
|
|
mydata['modefinancement'] = modefinancement
|
|
|
|
|
|
opco = ""
|
|
if ("opco" in df.keys()):
|
|
if (str(df['opco'].values[n])):
|
|
opco = str(df['opco'].values[n])
|
|
mydata['opco'] = opco
|
|
|
|
adresse = ""
|
|
if ("adresse" in df.keys()):
|
|
if (str(df['adresse'].values[n])):
|
|
adresse = str(df['adresse'].values[n])
|
|
mydata['adresse'] = adresse
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in df.keys()):
|
|
if (str(df['code_postal'].values[n])):
|
|
code_postal = str(df['code_postal'].values[n])
|
|
mydata['code_postal'] = code_postal
|
|
|
|
ville = ""
|
|
if ("ville" in df.keys()):
|
|
if (str(df['ville'].values[n])):
|
|
ville = str(df['ville'].values[n])
|
|
mydata['ville'] = ville
|
|
|
|
pays = ""
|
|
if ("pays" in df.keys()):
|
|
if (str(df['pays'].values[n])):
|
|
pays = str(df['pays'].values[n])
|
|
mydata['pays'] = pays
|
|
|
|
|
|
""""
|
|
Gestion du client de rattachement/
|
|
Avec l'email et le nom, on va aller récupérer l'_id du client
|
|
"""
|
|
client_rattachement_email = ""
|
|
if ("client_rattachement_email" in df.keys()):
|
|
if (str(df['client_rattachement_email'].values[n]) and str(df['client_rattachement_email'].values[n]) != "nan"):
|
|
client_rattachement_email = str(df['client_rattachement_email'].values[n])
|
|
|
|
|
|
client_rattachement_nom = ""
|
|
if ("client_rattachement_nom" in df.keys()):
|
|
if (str(df['client_rattachement_nom'].values[n]) and str(df['client_rattachement_nom'].values[n]) != "nan" ):
|
|
client_rattachement_nom = str(df['client_rattachement_nom'].values[n])
|
|
if (client_rattachement_email and client_rattachement_nom):
|
|
local_client_retval_qry = {'email':str(client_rattachement_email), 'nom':str(client_rattachement_nom),
|
|
'valide':'1', 'locked':'0', 'partner_recid' :str(partner_recid)}
|
|
|
|
local_client_retval_count = MYSY_GV.dbname['partner_client'].count_documents(local_client_retval_qry)
|
|
|
|
if( local_client_retval_count > 1 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) +"Ligne : "+str(n+2) +". Plusieurs clients correspondent aux critère de nom :"+str(client_rattachement_nom)+" et email : "+str(client_rattachement_email))
|
|
return False, "Ligne : "+str(n+2) +". Plusieurs clients correspondent aux critère de nom :"+str(client_rattachement_nom)+" et email : "+str(client_rattachement_email)
|
|
|
|
if (local_client_retval_count < 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : "+str(n+2) +". Aucun client ne repond aux critères de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email))
|
|
return False, "Ligne : "+str(n+2) +". Aucun client ne repond aux critères de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email)
|
|
|
|
local_client_retval_data = MYSY_GV.dbname['partner_client'].find_one(local_client_retval_qry)
|
|
if( local_client_retval_data is not None ):
|
|
mydata['client_rattachement_id'] = local_client_retval_data['_id']
|
|
|
|
|
|
mydata['status'] = str(df['status'].values[n]).strip()
|
|
if( str(mydata['status']) != "0" and str(mydata['status']) != "1" and str(mydata['status']) != "2"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'status' de ligne " + str(n) + " est incorrecte. Valeurs acceptées : 0,1,2")
|
|
return False, " Le champ status de la ligne " + str(n) + " est incorrecte. Valeurs acceptées : 0,1,2"
|
|
|
|
|
|
if( str(df['status'].values[n]).strip() == "1"):
|
|
mydata['inscription_validation_date'] = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
|
|
|
|
|
|
local_price = str(df['prix'].values[n]).strip()
|
|
local_status, new_price = mycommon.IsFloat(local_price)
|
|
if( local_status is False ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][ 3]) + " Le champ 'prix' de ligne " + str( n) + " est incorrecte.")
|
|
return False, " Le champ prix de la ligne " + str(n) + " est incorrecte. "
|
|
|
|
mydata['price'] = local_price
|
|
|
|
|
|
clean_dict = {k: mydata[k] for k in mydata if ( str(mydata[k]) != "nan") }
|
|
|
|
print( "#### clean_dict ", clean_dict)
|
|
status, retval = AddStagiairetoClass(clean_dict)
|
|
|
|
if( status is False ):
|
|
return status, retval
|
|
|
|
print(str(total_rows)+" participants ont été inserés")
|
|
|
|
return True, str(total_rows)+" participants ont été inserées / Mises à jour"
|
|
|
|
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 participants en masse "
|
|
|
|
|
|
|
|
"""
|
|
Fonction de controle du fichier
|
|
"""
|
|
def Controle_AddStagiairetoClass_mass_for_many_session(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',]
|
|
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 participants annulée")
|
|
return False, " Verifier votre API"
|
|
|
|
'''
|
|
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, " Verifier votre API, Toutes les informations techniques ne sont pas fournies"
|
|
|
|
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"
|
|
|
|
|
|
|
|
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 participants ")
|
|
return False, " Les information de connexion sont incorrectes. Impossible d'importer la liste des participants"
|
|
|
|
|
|
|
|
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 = ['formation_code_externe', 'code_session', 'prenom', 'nom', 'employeur',
|
|
'telephone', 'email', 'modefinancement', 'opco', 'status', 'prix', 'adresse', 'code_postal',
|
|
'ville', 'pays', 'client_rattachement_email', 'client_rattachement_nom']
|
|
|
|
|
|
# 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 = ", df.columns)
|
|
for val in df.columns:
|
|
#print(" ### val = ", val)
|
|
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 = ['prenom', 'nom', 'email', 'modefinancement', 'status', 'prix']
|
|
|
|
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 session.
|
|
session_data = MYSY_GV.dbname['session_formation'].find_one({'formation_session_id':str(session_id)})
|
|
if( session_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"
|
|
|
|
#print(" #### session_data = ",session_data)
|
|
"""
|
|
|
|
x = range(0, total_rows)
|
|
for n in x:
|
|
mydata = {}
|
|
class_external_code = str(df['formation_code_externe'].values[n])
|
|
#mydata['code_session'] = str(df['code_session'].values[n])
|
|
mydata['prenom'] = str(df['prenom'].values[n])
|
|
mydata['nom'] = str(df['nom'].values[n])
|
|
mydata['employeur'] = str(df['employeur'].values[n])
|
|
mydata['telephone'] = str(df['telephone'].values[n])
|
|
mydata['email'] = str(df['email'].values[n])
|
|
print(" contole du mail = ", mydata['email'])
|
|
regex = r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,7}\b'
|
|
if (not re.fullmatch(regex, str( mydata['email']) )):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " l'adresse email " + str(mydata['email']) + " est invalide")
|
|
return False, " l'adresse email -" + str(mydata['email']) + "- est invalide"
|
|
|
|
mydata['token'] = str(my_token)
|
|
|
|
"""
|
|
Recuperation de l'internal url de la formation a partir de la cle
|
|
- formation code externe
|
|
- partner_owner_recid
|
|
"""
|
|
qry = {'external_code':str(class_external_code), 'valide':'1', 'locked':'0', 'partner_owner_recid':str(partner_recid)}
|
|
print(" ### qry = ", qry)
|
|
myclass_data_count = MYSY_GV.dbname['myclass'].count_documents(qry)
|
|
#print(" ### myclass_data_count = ", myclass_data_count)
|
|
|
|
if( myclass_data_count != 1 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : " + str(
|
|
n + 2) + ": Le code externe de la formation et le code de la session ne correspondent pas .")
|
|
return False, "Ligne : " + str(
|
|
n + 2) + ": Le code externe de la formation et le code de la session ne correspondent pas."
|
|
|
|
|
|
myclass_data = MYSY_GV.dbname['myclass'].find_one({'external_code':str(class_external_code), 'valide':'1', 'locked':'0',
|
|
'partner_owner_recid':str(partner_recid)})
|
|
|
|
mysession_count_qry = {'class_internal_url': str(myclass_data['internal_url']), 'valide': '1',
|
|
'partner_owner_recid': str(partner_recid), 'code_session':str(df['code_session'].values[n]) }
|
|
|
|
print(" ### mysession_count_qry = ", mysession_count_qry)
|
|
|
|
mysession_count = MYSY_GV.dbname['session_formation'].count_documents(mysession_count_qry)
|
|
|
|
if( mysession_count != 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : " + str(
|
|
n + 2) + ": Le code externe de la formation et le code de la session ne correspondent pas (2).")
|
|
return False, "Ligne : " + str(
|
|
n + 2) + ": Le code externe de la formation et le code de la session ne correspondent pas (2)."
|
|
|
|
mysession_data = MYSY_GV.dbname['session_formation'].find_one(mysession_count_qry)
|
|
|
|
|
|
|
|
mydata['session_id'] = str(mysession_data['_id'])
|
|
mydata['class_internal_url'] = str(mysession_data['class_internal_url'])
|
|
|
|
"""
|
|
Recuperation de l''_id' de la session à partir de la clé
|
|
- formation code externe
|
|
- code_session
|
|
- partner_owner_recid
|
|
"""
|
|
|
|
"""
|
|
On verifie que le code de le session et le l'external class code correspondent.
|
|
En gros : que la formation en question a bien une session du meme code
|
|
"""
|
|
|
|
|
|
|
|
|
|
modefinancement = ""
|
|
if ("modefinancement" in df.keys()):
|
|
if (str(df['modefinancement'].values[n])):
|
|
modefinancement = str(df['modefinancement'].values[n])
|
|
mydata['modefinancement'] = modefinancement
|
|
|
|
|
|
opco = ""
|
|
if ("opco" in df.keys()):
|
|
if (str(df['opco'].values[n])):
|
|
opco = str(df['opco'].values[n])
|
|
mydata['opco'] = opco
|
|
|
|
adresse = ""
|
|
if ("adresse" in df.keys()):
|
|
if (str(df['adresse'].values[n])):
|
|
adresse = str(df['adresse'].values[n])
|
|
mydata['adresse'] = adresse
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in df.keys()):
|
|
if (str(df['code_postal'].values[n])):
|
|
code_postal = str(df['code_postal'].values[n])
|
|
mydata['code_postal'] = code_postal
|
|
|
|
ville = ""
|
|
if ("ville" in df.keys()):
|
|
if (str(df['ville'].values[n])):
|
|
ville = str(df['ville'].values[n])
|
|
mydata['ville'] = ville
|
|
|
|
pays = ""
|
|
if ("pays" in df.keys()):
|
|
if (str(df['pays'].values[n])):
|
|
pays = str(df['pays'].values[n])
|
|
mydata['pays'] = pays
|
|
|
|
|
|
""""
|
|
Gestion du client de rattachement/
|
|
Avec l'email et le nom, on va aller récupérer l'_id du client
|
|
"""
|
|
client_rattachement_email = ""
|
|
if ("client_rattachement_email" in df.keys()):
|
|
if (str(df['client_rattachement_email'].values[n]) and str(df['client_rattachement_email'].values[n]) != "nan"):
|
|
client_rattachement_email = str(df['client_rattachement_email'].values[n])
|
|
|
|
|
|
client_rattachement_nom = ""
|
|
if ("client_rattachement_nom" in df.keys()):
|
|
if (str(df['client_rattachement_nom'].values[n]) and str(df['client_rattachement_nom'].values[n]) != "nan" ):
|
|
client_rattachement_nom = str(df['client_rattachement_nom'].values[n])
|
|
if (client_rattachement_email and client_rattachement_nom):
|
|
local_client_retval_qry = {'email':str(client_rattachement_email), 'nom':str(client_rattachement_nom),
|
|
'valide':'1', 'locked':'0', 'partner_recid' :str(partner_recid)}
|
|
|
|
local_client_retval_count = MYSY_GV.dbname['partner_client'].count_documents(local_client_retval_qry)
|
|
|
|
if( local_client_retval_count > 1 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) +"Ligne : "+str(n+2) +". Plusieurs clients correspondent aux critère de nom :"+str(client_rattachement_nom)+" et email : "+str(client_rattachement_email))
|
|
return False, "Ligne : "+str(n+2) +". Plusieurs clients correspondent aux critère de nom :"+str(client_rattachement_nom)+" et email : "+str(client_rattachement_email)
|
|
|
|
if (local_client_retval_count < 1):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + "Ligne : "+str(n+2) +". Aucun client ne repond aux critères de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email))
|
|
return False, "Ligne : "+str(n+2) +". Aucun client ne repond aux critères de nom :" + str(
|
|
client_rattachement_nom) + " et email : " + str(client_rattachement_email)
|
|
|
|
local_client_retval_data = MYSY_GV.dbname['partner_client'].find_one(local_client_retval_qry)
|
|
if( local_client_retval_data is not None ):
|
|
mydata['client_rattachement_id'] = local_client_retval_data['_id']
|
|
|
|
|
|
mydata['status'] = str(df['status'].values[n]).strip()
|
|
if( str(mydata['status']) != "0" and str(mydata['status']) != "1" and str(mydata['status']) != "2"):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ 'status' de ligne " + str(n) + " est incorrecte. Valeurs acceptées : 0,1,2")
|
|
return False, " Le champ status de la ligne " + str(n) + " est incorrecte. Valeurs acceptées : 0,1,2"
|
|
|
|
|
|
if( str(df['status'].values[n]).strip() == "1"):
|
|
mydata['inscription_validation_date'] = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
|
|
local_price = str(df['prix'].values[n]).strip()
|
|
local_status, new_price = mycommon.IsFloat(local_price)
|
|
if( local_status is False ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][ 3]) + " Le champ 'prix' de ligne " + str( n) + " est incorrecte.")
|
|
return False, " Le champ prix de la ligne " + str(n) + " est incorrecte. "
|
|
|
|
mydata['price'] = local_price
|
|
|
|
|
|
clean_dict = {k: mydata[k] for k in mydata if ( str(mydata[k]) != "nan") }
|
|
|
|
print( "#### clean_dict ", clean_dict)
|
|
|
|
|
|
return True, str(total_rows)+" participants 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 participants a importer en masse "
|
|
|
|
|
|
|
|
|
|
"""
|
|
Cette fonction permet d'imprimer/telecharger la fichier d'un inscrit à une session.
|
|
Cette fonction va utiliser un template pour imprimer le modele
|
|
"""
|
|
def PrintAttendeeDetail_perSession(diction):
|
|
try:
|
|
field_list_obligatoire = ['session_id', 'token', 'attendee_email', '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 d'imprimer la fiche detaillée"
|
|
|
|
my_token = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
my_token = diction['token']
|
|
|
|
internal_url = ""
|
|
if ("internal_url" in diction.keys()):
|
|
if diction['internal_url']:
|
|
internal_url = diction['internal_url']
|
|
|
|
|
|
# Recuperation du recid du partenaire
|
|
partner_recid = mycommon.get_parnter_recid_from_token(str(my_token))
|
|
if partner_recid is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible d'imprimer la fiche detaillée")
|
|
return False, " Les informations d'identification sont invalides"
|
|
|
|
local_status, my_partner_data = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
|
if (local_status is not True):
|
|
return local_status, my_partner_data
|
|
|
|
|
|
RetObject = []
|
|
# Recuperation des infos de la l'inscription
|
|
qry = {'session_id': str(diction['session_id']),'email': str(diction['attendee_email']),
|
|
'class_internal_url':str(diction['internal_url'])}
|
|
|
|
print(" ### qry = ", qry)
|
|
|
|
local_Insc_retval = MYSY_GV.dbname['inscription'].find_one({'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email']),
|
|
'class_internal_url':str(diction['internal_url'])})
|
|
my_retrun_dict = {}
|
|
|
|
my_retrun_dict['session_id'] = local_Insc_retval['session_id']
|
|
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['date_du']:
|
|
date_du = local_Insc_retval['date_du']
|
|
my_retrun_dict['date_du'] = str(date_du)[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['date_au']:
|
|
date_au = local_Insc_retval['date_au']
|
|
my_retrun_dict['date_au'] = str(date_au)[0:10]
|
|
|
|
ville = ""
|
|
if ("ville" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['ville']:
|
|
code_postal = local_Insc_retval['ville']
|
|
my_retrun_dict['ville'] = ville
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['code_postal']:
|
|
code_postal = local_Insc_retval['code_postal']
|
|
my_retrun_dict['code_postal'] = code_postal
|
|
|
|
|
|
my_adresse = ""
|
|
if ("adresse" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['adresse']:
|
|
my_adresse = local_Insc_retval['adresse']
|
|
my_retrun_dict['adresse'] = my_adresse
|
|
|
|
my_nom = ""
|
|
if ("nom" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['nom']:
|
|
my_adresse = local_Insc_retval['nom']
|
|
my_retrun_dict['nom'] = my_nom
|
|
|
|
my_prenom = ""
|
|
if ("prenom" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['prenom']:
|
|
my_prenom = local_Insc_retval['prenom']
|
|
my_retrun_dict['prenom'] = my_prenom
|
|
|
|
my_employeur = ""
|
|
if ("employeur" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['employeur']:
|
|
my_employeur = local_Insc_retval['employeur']
|
|
my_retrun_dict['employeur'] = my_employeur
|
|
|
|
my_telephone = ""
|
|
if ("telephone" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['telephone']:
|
|
my_telephone = local_Insc_retval['telephone']
|
|
my_retrun_dict['telephone'] = my_telephone
|
|
|
|
my_email = ""
|
|
if ("email" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['email']:
|
|
my_email = local_Insc_retval['email']
|
|
my_retrun_dict['email'] = my_email
|
|
|
|
my_modefinancement = ""
|
|
if ("modefinancement" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['modefinancement']:
|
|
my_modefinancement = local_Insc_retval['modefinancement']
|
|
my_retrun_dict['modefinancement'] = my_modefinancement
|
|
|
|
my_opco = ""
|
|
if ("opco" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['opco']:
|
|
my_opco = local_Insc_retval['opco']
|
|
my_retrun_dict['opco'] = my_opco
|
|
|
|
my_class_internal_url = ""
|
|
if ("class_internal_url" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['class_internal_url']:
|
|
my_class_internal_url = local_Insc_retval['class_internal_url']
|
|
my_retrun_dict['class_internal_url'] = my_class_internal_url
|
|
|
|
my_status = ""
|
|
if ("status" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['status']:
|
|
my_status = local_Insc_retval['status']
|
|
my_retrun_dict['status'] = my_status
|
|
|
|
my_price = ""
|
|
if ("price" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['price']:
|
|
my_price = local_Insc_retval['price']
|
|
my_retrun_dict['price'] = my_price
|
|
|
|
|
|
if ("inscription_validation_date" in local_Insc_retval.keys()):
|
|
my_retrun_dict['inscription_validation_date'] = local_Insc_retval['inscription_validation_date']
|
|
|
|
if ("eval_eval" in local_Insc_retval.keys()):
|
|
my_retrun_dict['evaluation'] = local_Insc_retval['eval_eval']
|
|
|
|
if ("eval_note" in local_Insc_retval.keys()):
|
|
my_retrun_dict['note_eval'] = local_Insc_retval['eval_note']
|
|
|
|
if ("eval_date" in local_Insc_retval.keys()):
|
|
my_retrun_dict['date_eval'] = str(local_Insc_retval['eval_date'])[0:10]
|
|
|
|
v = local_Insc_retval['_id'].generation_time
|
|
my_retrun_dict['created_date'] = str(v.strftime("%d/%m/%Y"))
|
|
|
|
my_retrun_dict['date_impression'] = str(datetime.today().strftime("%d/%m/%Y"))
|
|
|
|
# Recuperation des infotrmations de la formation
|
|
local_formation = MYSY_GV.dbname['myclass'].find_one(
|
|
{'internal_url': str(local_Insc_retval['class_internal_url']),
|
|
'partner_owner_recid':str(partner_recid)})
|
|
|
|
my_local_title = ""
|
|
if ("title" in local_formation.keys()):
|
|
if local_formation['title']:
|
|
my_retrun_dict['class_title'] = local_formation['title']
|
|
my_local_title = local_formation['title']
|
|
|
|
local_query = {'_id':ObjectId(str(local_Insc_retval['session_id'])), 'valide':'1',
|
|
'partner_owner_recid':str(partner_recid)}
|
|
|
|
print(" ### local_query = ", local_query)
|
|
|
|
# Recuperation du formation depuis la collection "session_formation"
|
|
tmp_val = MYSY_GV.dbname['session_formation'].find_one(local_query)
|
|
if( tmp_val is None):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " Impossible d'imprimer la fiche detaillée : code session erronée ")
|
|
return False, " Impossible d'imprimer la fiche detaillée : code session erronée "
|
|
|
|
my_trainer = ""
|
|
if ("formateur" in tmp_val.keys()):
|
|
if tmp_val['formateur']:
|
|
my_trainer = tmp_val['formateur']
|
|
my_retrun_dict['formateur'] = tmp_val['formateur']
|
|
|
|
if (my_trainer == ""):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " Impossible d'imprimer la fiche detaillée : Aucun formateur designé pour la session")
|
|
return False, " Impossible d'imprimer la fiche detaillée : Aucun formateur designé pour la session"
|
|
|
|
|
|
if ("distantiel" in tmp_val.keys()):
|
|
if tmp_val['distantiel']:
|
|
my_retrun_dict['distantiel'] = tmp_val['distantiel']
|
|
|
|
if ("presentiel" in tmp_val.keys()):
|
|
if tmp_val['presentiel']:
|
|
my_retrun_dict['presentiel'] = tmp_val['presentiel']
|
|
|
|
my_partner = ""
|
|
if ("institut_formation" in local_formation.keys()):
|
|
if local_formation['institut_formation']:
|
|
my_partner = local_formation['institut_formation']
|
|
my_retrun_dict['partner'] = my_partner
|
|
|
|
my_img_url = ""
|
|
if ("img_url" in local_formation.keys()):
|
|
if local_formation['img_url']:
|
|
my_img_url = local_formation['img_url']
|
|
my_retrun_dict['img_url'] = my_img_url
|
|
|
|
|
|
|
|
##############################
|
|
# Recuperation des fiches de presence
|
|
tab_presences = []
|
|
for val_tmp in MYSY_GV.dbname['emargement'].find({'session_id':str(local_Insc_retval['session_id']),
|
|
'email':str(local_Insc_retval['email'])}).sort([("date", pymongo.ASCENDING)]):
|
|
local_tmp = {}
|
|
local_tmp['email'] = val_tmp['email']
|
|
local_tmp['matin'] = val_tmp['matin']
|
|
local_tmp['apresmidi'] = val_tmp['apresmidi']
|
|
local_tmp['date'] = val_tmp['date']
|
|
|
|
tab_presences.append(local_tmp)
|
|
|
|
|
|
# Recuperation image logo du partenaire en base de donnée
|
|
qery_images = {'locked': '0', 'valide': '1', 'related_collection': 'partnair_account',
|
|
'related_collection_recid': str(my_partner_data['recid']), 'type_img':'logo'}
|
|
|
|
|
|
partner_media_logo = MYSY_GV.dbname['mysy_images'].find_one(qery_images)
|
|
|
|
is_partner_logo = True
|
|
is_partner_logo_img = ""
|
|
if( partner_media_logo is None or "img" not in partner_media_logo.keys()):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " La partner n'a pas de logo, le logo par defaut sera utilisé")
|
|
|
|
is_partner_logo = False
|
|
else:
|
|
is_partner_logo_img = "data:image/png;base64," + str(partner_media_logo['img'])
|
|
|
|
if( is_partner_logo is False ):
|
|
# récupérer l'image logo par default
|
|
default_qery_images = {'locked': '0', 'valide': '1', 'related_collection': 'partnair_account', 'type_img': 'logo_default'}
|
|
partner_media_logo = MYSY_GV.dbname['mysy_images'].find_one(default_qery_images)
|
|
|
|
is_partner_logo_img = "data:image/png;base64," + str(partner_media_logo['img'])
|
|
|
|
|
|
my_retrun_dict['default_logo_partner'] = is_partner_logo_img
|
|
|
|
#print(" ### my_retrun_dict =",my_retrun_dict)
|
|
|
|
templateLoader = jinja2.FileSystemLoader(searchpath="./")
|
|
templateEnv = jinja2.Environment(loader=templateLoader)
|
|
TEMPLATE_FILE = "Template/fiche_detail_stagiaire_tpl.html"
|
|
template = templateEnv.get_template(TEMPLATE_FILE)
|
|
# This data can come from database query
|
|
body = {
|
|
"data": my_retrun_dict,
|
|
"presences": tab_presences
|
|
}
|
|
|
|
# print(" ### body = " + str(body))
|
|
|
|
sourceHtml = template.render(json_data=body["data"], presences=body["presences"])
|
|
mycode = str(datetime.now().timestamp()).replace(".", '').replace(',', '')
|
|
orig_file_name = "fichier_personnel_"+str(mycode)[:-3]+"pdf"
|
|
outputFilename = str(MYSY_GV.EMARGEMENT_DIRECTORY) + str(orig_file_name)
|
|
|
|
# open output file for writing (truncated binary)
|
|
resultFile = open(outputFilename, "w+b")
|
|
|
|
# convert HTML to PDF
|
|
pisaStatus = pisa.CreatePDF(
|
|
src=sourceHtml, # the HTML to convert
|
|
dest=resultFile) # file handle to receive result
|
|
|
|
# close output file
|
|
resultFile.close()
|
|
|
|
# print(" ### outputFilename = "+str(outputFilename))
|
|
if os.path.exists(outputFilename):
|
|
# print(" ### ok os.path.exists(outputFilename) "+str(outputFilename))
|
|
return True, send_file(outputFilename, as_attachment=True)
|
|
|
|
# return True on success and False on errors
|
|
print(pisaStatus.err, type(pisaStatus.err))
|
|
|
|
return True, " le fichier generé "
|
|
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible d'imprimer la fiche detaillée"
|
|
|
|
|
|
|
|
|
|
""" Creation d'un evaluation sur une formation
|
|
Les infos d'evaluation sont rattachées à la collection inscription.
|
|
|
|
eval_date :
|
|
eval_note :
|
|
eval_eval :
|
|
eval_pedagogie :
|
|
|
|
"""
|
|
def Evaluation_Class(diction):
|
|
try:
|
|
|
|
field_list_obligatoire = ['inscription_id', 'eval_note', 'eval_eval', 'eval_pedagogie', '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, " Les informations fournies sont incorrectes"
|
|
|
|
|
|
|
|
note = str(diction['eval_note']).strip()
|
|
if( mycommon.IsFloat( note ) is False ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " La note d'evaluation est incorrecte ")
|
|
return False, " La note d'evaluation est incorrecte "
|
|
|
|
mydata = {}
|
|
mydata['eval_date'] = str(datetime.now().strftime("%d/%m/%Y, %H:%M:%S"))
|
|
mydata['eval_note'] = str(diction['eval_note']).strip()
|
|
mydata['eval_status'] = "1"
|
|
mydata['eval_eval'] = str(diction['eval_eval']).strip()
|
|
mydata['eval_pedagogie'] = str(diction['eval_pedagogie']).strip()
|
|
|
|
ret_val = MYSY_GV.dbname['inscription'].find_one_and_update({'_id': ObjectId(str(str(diction['inscription_id']).strip())),},
|
|
{"$set": mydata},
|
|
upsert=False,
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
|
|
if ret_val is None or ret_val['_id'] is None:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible d'enregistrer l'evaluation ")
|
|
return False, " Impossible d'enregistrer l'evaluation "
|
|
|
|
|
|
# Declencer l'envoi de la notification de l'evaluation
|
|
email_mgt.EmailNotifEvaluation_Done(diction)
|
|
return True, " L'evaluation a bien été enregistrée"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de créer l'evaluation"
|
|
|
|
"""
|
|
Cette fonction verifie si un token d'evaluation est valide.
|
|
|
|
Un token est valide si :
|
|
token = ObjectId existe
|
|
internal_url et le objectId sont coherents (meme ligne dans la collection)
|
|
L'evaluation n'a pas deja ete faite.
|
|
|
|
"""
|
|
def MySyckeckEvaluationToken(diction):
|
|
try:
|
|
field_list_obligatoire = ['eval_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, " Les informations fournies sont incorrectes"
|
|
|
|
eval_token = ""
|
|
if ("eval_token" in diction.keys()):
|
|
if diction['eval_token']:
|
|
eval_token = diction['eval_token']
|
|
|
|
internal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
internal_url = diction['class_internal_url']
|
|
|
|
#local_qry = {'class_internal_url':internal_url, '_id': ObjectId(eval_token), "eval_date":{"$exists":False} }
|
|
|
|
#print(" ### local_qry =",local_qry)
|
|
tmp_count = MYSY_GV.dbname['inscription'].count_documents({'class_internal_url':internal_url,
|
|
'_id': ObjectId(eval_token), "eval_date":{"$exists":False} } )
|
|
|
|
if (tmp_count != 1):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " "+str(tmp_count)+" est different de 1. impossible de faire l'evaluation")
|
|
return False, " Impossible de faire l'evaluation. Verifier les informations fournies"
|
|
|
|
|
|
return True, "Ok"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de verifier la validé du token"
|
|
|
|
|
|
"""
|
|
Cette fonction envoie l'email de demande d'evaluation
|
|
"""
|
|
def SendTrainingEvaluationEmail(diction):
|
|
try:
|
|
field_list_obligatoire = ['session_id', 'token', 'attendee_email', '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, " Les informations fournies sont incorrectes"
|
|
|
|
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"
|
|
|
|
|
|
# Recuperation du recid du partenaire
|
|
partner_recid = mycommon.get_parnter_recid_from_token(str(my_token))
|
|
if partner_recid is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible d'imprimer la fiche detaillée")
|
|
return False, " Les informations fournies sont incorrectes"
|
|
|
|
# Verifier qui la formation n'a pas deja été evaluée
|
|
tmp_count = MYSY_GV.dbname['inscription'].count_documents({'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email']),
|
|
'class_internal_url': str(diction['class_internal_url'],),
|
|
'partner_owner_recid': str(partner_recid),
|
|
"eval_date": {"$exists": True}})
|
|
|
|
if (tmp_count > 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Cette formation a déjà été évaluée")
|
|
return False, " Cette formation a déjà été évaluée"
|
|
|
|
|
|
RetObject = []
|
|
# Recuperation des infos de la formation
|
|
qry = {'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email']),
|
|
'class_internal_url': str(diction['class_internal_url']),
|
|
'partner_owner_recid': str(partner_recid),
|
|
}
|
|
|
|
print(" ### qry = ", qry)
|
|
local_Insc_retval = MYSY_GV.dbname['inscription'].find_one({'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email']),
|
|
'class_internal_url': str(diction['class_internal_url']),
|
|
'partner_owner_recid': str(partner_recid),
|
|
})
|
|
|
|
my_retrun_dict = {}
|
|
|
|
print(' ##### local_Insc_retval = ', local_Insc_retval)
|
|
|
|
my_retrun_dict['token_eval'] = local_Insc_retval['_id']
|
|
if( "date_du" in local_Insc_retval.keys() ):
|
|
my_retrun_dict['date_du'] = str(local_Insc_retval['date_du'])[1:10]
|
|
else:
|
|
my_retrun_dict['date_du'] = ""
|
|
|
|
if ("date_au" in local_Insc_retval.keys() ):
|
|
my_retrun_dict['date_au'] = str(local_Insc_retval['date_au'])[0:10]
|
|
else:
|
|
my_retrun_dict['date_au'] = ""
|
|
|
|
my_retrun_dict['session_id'] = str(local_Insc_retval['_id'])
|
|
|
|
ville = ""
|
|
if ("ville" in local_Insc_retval.keys() and local_Insc_retval['ville']):
|
|
ville = local_Insc_retval['ville']
|
|
my_retrun_dict['ville'] = ville
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_Insc_retval.keys() and local_Insc_retval['code_postal']):
|
|
code_postal = local_Insc_retval['code_postal']
|
|
my_retrun_dict['code_postal'] = code_postal
|
|
|
|
internal_url = ""
|
|
if ("class_internal_url" in local_Insc_retval.keys() and local_Insc_retval['class_internal_url']):
|
|
internal_url = local_Insc_retval['class_internal_url']
|
|
my_retrun_dict['internal_url'] = internal_url
|
|
|
|
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_Insc_retval.keys() and local_Insc_retval['adresse']):
|
|
adresse = local_Insc_retval['adresse']
|
|
my_retrun_dict['adresse'] = adresse
|
|
|
|
nom = ""
|
|
if ("nom" in local_Insc_retval.keys() and local_Insc_retval['nom']):
|
|
nom = local_Insc_retval['nom']
|
|
my_retrun_dict['nom'] = nom
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_Insc_retval.keys() and local_Insc_retval['prenom']):
|
|
prenom = local_Insc_retval['prenom']
|
|
my_retrun_dict['prenom'] = prenom
|
|
|
|
employeur = ""
|
|
if ("employeur" in local_Insc_retval.keys() and local_Insc_retval['employeur']):
|
|
employeur = local_Insc_retval['employeur']
|
|
my_retrun_dict['employeur'] = employeur
|
|
|
|
telephone = ""
|
|
if ("telephone" in local_Insc_retval.keys() and local_Insc_retval['telephone']):
|
|
telephone = local_Insc_retval['telephone']
|
|
my_retrun_dict['telephone'] = telephone
|
|
|
|
|
|
my_retrun_dict['email'] = local_Insc_retval['email']
|
|
|
|
# Recuperation des infotrmations de la formation
|
|
print(" ### str(local_Insc_retval['class_internal_url']) = ",str(local_Insc_retval['class_internal_url']) )
|
|
local_formation = MYSY_GV.dbname['myclass'].find_one(
|
|
{'internal_url': str(local_Insc_retval['class_internal_url'])})
|
|
my_retrun_dict['title'] = local_formation['title']
|
|
|
|
# Recuperation des info de session
|
|
local_session_info = MYSY_GV.dbname['session_formation'].find_one({'_id': ObjectId(str(diction['session_id'])),
|
|
'valide': '1'})
|
|
|
|
|
|
if( local_session_info is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de récupérer les données de la session de formation")
|
|
return False, " Impossible de récupérer les données de la session de formation"
|
|
|
|
if ("code_session" in local_session_info.keys()):
|
|
if local_session_info['code_session']:
|
|
my_retrun_dict['code_session'] = local_session_info['code_session']
|
|
|
|
if ("distantiel" in local_session_info.keys()):
|
|
if local_session_info['distantiel']:
|
|
my_retrun_dict['distantiel'] = local_session_info['distantiel']
|
|
|
|
if ("presentiel" in local_session_info.keys()):
|
|
if local_session_info['presentiel']:
|
|
my_retrun_dict['presentiel'] = local_session_info['presentiel']
|
|
|
|
session_ondemande = ""
|
|
if ("session_ondemande" in local_session_info.keys()):
|
|
if local_session_info['session_ondemande']:
|
|
session_ondemande = local_session_info['session_ondemande']
|
|
|
|
my_retrun_dict['session_ondemande'] = session_ondemande
|
|
|
|
|
|
# Envoi de l'email de notification au formateur
|
|
local_status, local_message = email_session.Evaluation_training_confirmation_mail(my_retrun_dict)
|
|
|
|
return local_status, str(local_message)
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible d'envoyer la demande d'evaluation"
|
|
|
|
|
|
|
|
|
|
"""
|
|
Cette fonction envoie le certificat d'un stagiaire
|
|
"""
|
|
def SendAttendeeCertification(diction):
|
|
try:
|
|
|
|
field_list_obligatoire = ['session_id', 'token', 'attendee_email', '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, " Les informations fournies sont incorrectes"
|
|
|
|
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"
|
|
|
|
|
|
# Recuperation du recid du partenaire
|
|
partner_recid = mycommon.get_parnter_recid_from_token(str(my_token))
|
|
if partner_recid is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible d'imprimer la fiche detaillée")
|
|
return False, " Les informations fournies sont incorrectes"
|
|
|
|
# Verifier qui la formation n'a pas deja été evaluée
|
|
tmp_count = MYSY_GV.dbname['inscription'].count_documents({'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email']),
|
|
'class_internal_url': str(diction['class_internal_url']),
|
|
"certification_send_date": {"$exists": True}})
|
|
|
|
if (tmp_count > 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Vous avez deja envoyé le certificat")
|
|
return False, " Vous avez deja envoyé le certificat"
|
|
|
|
# Recuperation du type/nom de la certifcation depuis la collecion "session_formation"
|
|
session_formation = MYSY_GV.dbname['session_formation'].find_one({'_id': ObjectId(str(diction['session_id'])),
|
|
'class_internal_url': str(
|
|
diction['class_internal_url']),
|
|
'valide': "1"})
|
|
|
|
if( session_formation['attestation_certif'] is None ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " impossible de trouver le modele d'attestation")
|
|
return False, " impossible de trouver le modele d'attestation"
|
|
|
|
date_fin_session = str(session_formation['date_fin'] )[0:10]
|
|
local_status = mycommon.CheckisDate(date_fin_session)
|
|
if( local_status is False ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " La date de fin de session de formation est incorrecte.")
|
|
return False, " La date de fin de session de formation est incorrecte."
|
|
|
|
mytoday = datetime.today().strftime("%d/%m/%Y")
|
|
"""
|
|
if (datetime.strptime(str(date_fin_session).strip(), '%d/%m/%Y') > datetime.strptime(str(mytoday).strip(), '%d/%m/%Y')):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Vous ne pouvez pas delivrer de certificat avant la date de fin de la session de formation ")
|
|
return False, " Vous ne pouvez pas delivrer de certificat avant la date de fin de la session de formation "
|
|
"""
|
|
print(" #### attestation_certif = ", str(session_formation['attestation_certif']))
|
|
attestation_certificat = MYSY_GV.dbname['attestation_certificat'].find_one({'nom': str(session_formation['attestation_certif']),
|
|
'valide': "1"})
|
|
|
|
if ( attestation_certificat is None or attestation_certificat['template_name'] is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Aucun type d'attestation/certificat trouvé 1")
|
|
return False, " Aucun type d'attestation/certificat trouvé "
|
|
|
|
my_retrun_dict = {}
|
|
|
|
my_retrun_dict['partner_recid'] = partner_recid
|
|
|
|
my_template = ""
|
|
if ("template_name" in attestation_certificat.keys() and attestation_certificat['template_name']):
|
|
my_template = attestation_certificat['template_name']
|
|
|
|
if( str(my_template).strip() == ""):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Aucun type d'attestation/certificat trouvé 2")
|
|
return False, " Aucun type d'attestation/certificat trouvé "
|
|
|
|
my_retrun_dict['attestation_tmpl'] = attestation_certificat['template_name']
|
|
|
|
# Recuperation des info de l'inscrit
|
|
local_qry = {'session_id': str(diction['session_id']),
|
|
'class_internal_url': str(
|
|
diction['class_internal_url']),
|
|
'email': str(diction['attendee_email'])}
|
|
|
|
print("### "+str(inspect.stack()[0][3]) + "local_qry = ", local_qry )
|
|
local_Insc_retval = MYSY_GV.dbname['inscription'].find_one({'session_id': str(diction['session_id']),
|
|
'class_internal_url': str(
|
|
diction['class_internal_url']),
|
|
'email': str(diction['attendee_email'])})
|
|
|
|
if (local_Insc_retval is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de récupérer les données de l'inscrit")
|
|
return False, " Impossible de récupérer les données de l'inscrit"
|
|
|
|
my_retrun_dict['date_du'] = local_Insc_retval['date_du']
|
|
my_retrun_dict['date_au'] = local_Insc_retval['date_au']
|
|
|
|
ville = ""
|
|
if ("ville" in local_Insc_retval.keys() and local_Insc_retval['ville']):
|
|
ville = local_Insc_retval['ville']
|
|
my_retrun_dict['ville'] = ville
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_Insc_retval.keys() and local_Insc_retval['code_postal']):
|
|
code_postal = local_Insc_retval['code_postal']
|
|
my_retrun_dict['code_postal'] = code_postal
|
|
|
|
internal_url = ""
|
|
if ("class_internal_url" in local_Insc_retval.keys() and local_Insc_retval['class_internal_url']):
|
|
internal_url = local_Insc_retval['class_internal_url']
|
|
my_retrun_dict['code_postal'] = internal_url
|
|
|
|
|
|
my_retrun_dict['inscription_id'] = local_Insc_retval['_id']
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_Insc_retval.keys() and local_Insc_retval['adresse']):
|
|
adresse = local_Insc_retval['adresse']
|
|
my_retrun_dict['adresse'] = adresse
|
|
|
|
nom = ""
|
|
if ("nom" in local_Insc_retval.keys() and local_Insc_retval['nom']):
|
|
nom = local_Insc_retval['nom']
|
|
my_retrun_dict['nom'] = nom
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_Insc_retval.keys() and local_Insc_retval['prenom']):
|
|
prenom = local_Insc_retval['prenom']
|
|
my_retrun_dict['prenom'] = prenom
|
|
|
|
employeur = ""
|
|
if ("employeur" in local_Insc_retval.keys() and local_Insc_retval['employeur']):
|
|
employeur = local_Insc_retval['employeur']
|
|
my_retrun_dict['employeur'] = employeur
|
|
|
|
telephone = ""
|
|
if ("telephone" in local_Insc_retval.keys() and local_Insc_retval['telephone']):
|
|
telephone = local_Insc_retval['telephone']
|
|
my_retrun_dict['telephone'] = telephone
|
|
|
|
formateur = ""
|
|
if ("formateur" in session_formation.keys() and session_formation['formateur']):
|
|
formateur = session_formation['formateur']
|
|
my_retrun_dict['formateur'] = formateur
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in session_formation.keys() and session_formation['presentiel']):
|
|
presentiel = session_formation['presentiel']
|
|
my_retrun_dict['presentiel'] = presentiel
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in session_formation.keys() and session_formation['distantiel']):
|
|
distantiel = session_formation['distantiel']
|
|
my_retrun_dict['distantiel'] = distantiel
|
|
|
|
|
|
#my_retrun_dict['formateur'] = session_formation['formateur']
|
|
|
|
my_retrun_dict['email'] = local_Insc_retval['email']
|
|
|
|
# Recuperation des infotrmations de la formation
|
|
##print(" ## str(local_Insc_retval['class_internal_url']) = ", str(local_Insc_retval['class_internal_url']))
|
|
local_formation = MYSY_GV.dbname['myclass'].find_one(
|
|
{'internal_url': str(local_Insc_retval['class_internal_url'])})
|
|
my_retrun_dict['title'] = local_formation['title']
|
|
|
|
"""
|
|
field_list_obligatoire = ['partner_recid', 'session_id', 'class_internal_url', 'class_title' ,
|
|
'email_participant']
|
|
"""
|
|
attestation_dict = {}
|
|
attestation_dict['partner_recid'] = str(partner_recid)
|
|
attestation_dict['session_id'] = str(diction['session_id'])
|
|
attestation_dict['class_internal_url'] = str(local_Insc_retval['class_internal_url'])
|
|
attestation_dict['class_title'] = local_formation['title']
|
|
attestation_dict['email_participant'] = local_Insc_retval['email']
|
|
attestation_dict['attestation_tmpl'] = attestation_certificat['template_name']
|
|
|
|
print(" ### attestation_dict = ", attestation_dict)
|
|
|
|
# Envoi de l'email de notification au formateur
|
|
local_status, local_message = email_session.SendAttestion_to_attendee_by_email(attestation_dict)
|
|
|
|
return local_status, str(local_message)
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible d'envoyer l'attestation"
|
|
|
|
|
|
""" Cette fonction imprime l'attestation
|
|
"""
|
|
|
|
|
|
def PrintAttendeeCertification(diction):
|
|
try:
|
|
|
|
field_list_obligatoire = ['session_id', 'token', 'attendee_email', '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, " Les informations fournies sont incorrectes"
|
|
|
|
my_token = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
my_token = diction['token']
|
|
|
|
# Recuperation du recid du partenaire
|
|
partner_recid = mycommon.get_parnter_recid_from_token(str(my_token))
|
|
if partner_recid is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible d'imprimer la fiche detaillée")
|
|
return False, " Les informations fournies sont incorrectes"
|
|
|
|
# Verifier qui la formation n'a pas deja été evaluée
|
|
tmp_count = MYSY_GV.dbname['inscription'].count_documents({'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email']),
|
|
"certification_send": {"$exists": True}})
|
|
|
|
if (tmp_count > 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Vous avez deja envoyé le certificat")
|
|
return False, " Vous avez deja envoyé le certificat"
|
|
|
|
# Recuperation des données du partenaire
|
|
local_partner = MYSY_GV.dbname['partnair_account'].find_one({'recid': str(partner_recid),
|
|
'active': "1",
|
|
'locked':'0'})
|
|
|
|
if( local_partner is None):
|
|
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 "
|
|
|
|
my_retrun_dict = {}
|
|
|
|
partner_nom = ""
|
|
if ("nom" in local_partner.keys()):
|
|
partner_nom = local_partner['nom']
|
|
my_retrun_dict['partner'] = partner_nom
|
|
|
|
num_nda = ""
|
|
if ("num_nda" in local_partner.keys()):
|
|
num_nda = local_partner['num_nda']
|
|
my_retrun_dict['num_declation'] = num_nda
|
|
|
|
mysy_partner_adr_city = ""
|
|
if ("adr_city" in local_partner.keys()):
|
|
mysy_partner_adr_city = local_partner['adr_city']
|
|
my_retrun_dict['mysy_partner_adr_city'] = mysy_partner_adr_city
|
|
|
|
my_retrun_dict['cachet_signature'] = "https://img.mysy-training.com/perso/mysy_cachet.png"
|
|
ct = datetime.now()
|
|
ts = ct.timestamp()
|
|
date_jour = ct.strftime("%d/%m/%Y")
|
|
my_retrun_dict['date_jour'] = str(date_jour)
|
|
|
|
# Recuperation du type/nom de la certifcation depuis la collecion "session_formation"
|
|
session_formation = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'_id': ObjectId(str(diction['session_id'])),
|
|
'valide': "1", 'class_internal_url':str(diction['internal_url'])})
|
|
|
|
if ("attestation_certif" not in session_formation.keys()):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " impossible de trouver le modele d'attestation")
|
|
return False, " impossible de trouver le modele d'attestation"
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in session_formation.keys()):
|
|
distantiel = session_formation['distantiel']
|
|
my_retrun_dict['distantiel'] = distantiel
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in session_formation.keys()):
|
|
distantiel = session_formation['formateur']
|
|
my_retrun_dict['distantiel'] = distantiel
|
|
|
|
formateur = ""
|
|
if ("formateur" in session_formation.keys()):
|
|
formateur = session_formation['formateur']
|
|
my_retrun_dict['formateur'] = formateur
|
|
|
|
contenu_ftion = ""
|
|
if ("contenu_ftion" in session_formation.keys()):
|
|
contenu_ftion = str(session_formation['contenu_ftion']).replace('<p>', '').replace('</p>', '').replace("\r\n", '<br/>')
|
|
my_retrun_dict['contenu_ftion'] = contenu_ftion
|
|
|
|
|
|
# Recuperation des données de l'attestation
|
|
attestation_certificat = MYSY_GV.dbname['attestation_certificat'].find_one(
|
|
{'nom': str(session_formation['attestation_certif']),
|
|
'valide': "1"})
|
|
|
|
if( attestation_certificat is None ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " impossible de trouver le modele d'attestation (2)")
|
|
return False, " impossible de trouver le modele d'attestation (2)"
|
|
|
|
if ("template_name" not in attestation_certificat.keys()):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " impossible de trouver le modele d'attestation (3)")
|
|
return False, " impossible de trouver le modele d'attestation (3)"
|
|
|
|
|
|
|
|
my_retrun_dict['attestation_tmpl'] = attestation_certificat['template_name']
|
|
|
|
# Recuperation des info de l'inscrit
|
|
local_Insc_retval = MYSY_GV.dbname['inscription'].find_one({'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email'])})
|
|
|
|
if (local_Insc_retval is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de récupérer les données de l'inscrit")
|
|
return False, " Impossible de récupérer les données de l'inscrit"
|
|
|
|
my_retrun_dict['date_du'] = str(local_Insc_retval['date_du'])[0:10]
|
|
my_retrun_dict['date_au'] = str(local_Insc_retval['date_au'])[0:10]
|
|
|
|
ville = ""
|
|
if ("ville" in local_Insc_retval.keys()):
|
|
ville = local_Insc_retval['ville']
|
|
my_retrun_dict['ville'] = ville
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_Insc_retval.keys()):
|
|
code_postal = local_Insc_retval['code_postal']
|
|
my_retrun_dict['code_postal'] = code_postal
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in local_Insc_retval.keys()):
|
|
class_internal_url = local_Insc_retval['class_internal_url']
|
|
my_retrun_dict['internal_url'] = class_internal_url
|
|
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_Insc_retval.keys()):
|
|
adresse = local_Insc_retval['adresse']
|
|
my_retrun_dict['adresse'] = adresse
|
|
|
|
nom = ""
|
|
if ("nom" in local_Insc_retval.keys()):
|
|
nom = local_Insc_retval['nom']
|
|
my_retrun_dict['nom'] = nom
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_Insc_retval.keys()):
|
|
prenom = local_Insc_retval['prenom']
|
|
my_retrun_dict['prenom'] = prenom
|
|
|
|
employeur = ""
|
|
if ("employeur" in local_Insc_retval.keys()):
|
|
employeur = local_Insc_retval['employeur']
|
|
my_retrun_dict['employeur'] = employeur
|
|
|
|
telephone = ""
|
|
if ("telephone" in local_Insc_retval.keys()):
|
|
telephone = local_Insc_retval['telephone']
|
|
my_retrun_dict['telephone'] = telephone
|
|
|
|
email = ""
|
|
if ("email" in local_Insc_retval.keys()):
|
|
email = local_Insc_retval['email']
|
|
my_retrun_dict['email'] = email
|
|
|
|
|
|
|
|
# Recuperation des infotrmations de la formation
|
|
#print(" ## str(local_Insc_retval['class_internal_url']) = ", str(local_Insc_retval['class_internal_url']))
|
|
local_formation = MYSY_GV.dbname['myclass'].find_one(
|
|
{'internal_url': str(local_Insc_retval['class_internal_url'])})
|
|
|
|
if( local_formation is None ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de récupérer les données de la formation ")
|
|
return False, " Impossible de récupérer les données de la formation"
|
|
|
|
title = ""
|
|
if ("title" in local_formation.keys()):
|
|
title = local_formation['title']
|
|
my_retrun_dict['class_title'] = title
|
|
|
|
logo_url = ""
|
|
if ("img_url" in local_formation.keys()):
|
|
logo_url = local_formation['img_url']
|
|
my_retrun_dict['logo_url'] = logo_url
|
|
|
|
|
|
templateLoader = jinja2.FileSystemLoader(searchpath="./")
|
|
templateEnv = jinja2.Environment(loader=templateLoader)
|
|
TEMPLATE_FILE = "Template/"+str(my_retrun_dict['attestation_tmpl'])+".html"
|
|
template = templateEnv.get_template(TEMPLATE_FILE)
|
|
# This data can come from database query
|
|
body = {
|
|
"data": my_retrun_dict,
|
|
|
|
}
|
|
|
|
print(" ### body = " + str(body))
|
|
|
|
sourceHtml = template.render(json_data=body["data"])
|
|
mycode = str(datetime.now().timestamp()).replace(".", '').replace(',', '')
|
|
orig_file_name = "Attestation_" + str(mycode)[:-3] + "pdf"
|
|
|
|
outputFilename = str(MYSY_GV.TEMPORARY_DIRECTORY) + str(orig_file_name)
|
|
|
|
# open output file for writing (truncated binary)
|
|
resultFile = open(outputFilename, "w+b")
|
|
|
|
# convert HTML to PDF
|
|
pisaStatus = pisa.CreatePDF(
|
|
src=sourceHtml, # the HTML to convert
|
|
dest=resultFile) # file handle to receive result
|
|
|
|
# close output file
|
|
resultFile.close()
|
|
|
|
# print(" ### outputFilename = "+str(outputFilename))
|
|
if os.path.exists(outputFilename):
|
|
# print(" ### ok os.path.exists(outputFilename) "+str(outputFilename))
|
|
return True, send_file(outputFilename, as_attachment=True)
|
|
|
|
# return True on success and False on errors
|
|
print(pisaStatus.err, type(pisaStatus.err))
|
|
|
|
return True, " le fichier generé "
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible d'envoyer l'attestation"
|
|
|
|
|
|
"""
|
|
Cette fonction récupérer la liste des evaluations d'une session de formation
|
|
"""
|
|
def GetListEvaluation_Session(diction):
|
|
try:
|
|
field_list_obligatoire = ['session_id', 'token']
|
|
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Les informations fournies sont incorrectes"
|
|
|
|
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"
|
|
|
|
|
|
# Recuperation du recid du partenaire
|
|
partner_recid = mycommon.get_parnter_recid_from_token(str(my_token))
|
|
if partner_recid is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer la liste des evaluations")
|
|
return False, " Les informations fournies sont incorrectes"
|
|
|
|
RetObject = []
|
|
val_tmp = 1
|
|
|
|
#qry = {'session_id': str(diction['session_id']), 'partner_owner_recid':str(partner_recid)}
|
|
|
|
|
|
# Recuperation des infos de la formation
|
|
for local_Insc_retval in MYSY_GV.dbname['inscription'].find({'session_id': str(diction['session_id']), 'partner_owner_recid':str(partner_recid)}):
|
|
user = {}
|
|
user['id'] = str(val_tmp)
|
|
val_tmp = val_tmp + 1
|
|
user['session_id'] = local_Insc_retval['session_id']
|
|
user['email'] = local_Insc_retval['email']
|
|
user['nom'] = local_Insc_retval['nom']
|
|
user['prenom'] = local_Insc_retval['prenom']
|
|
|
|
if ("eval_date" in local_Insc_retval.keys()):
|
|
user['eval_date'] = local_Insc_retval['eval_date']
|
|
else:
|
|
user['eval_date'] = "---"
|
|
|
|
|
|
if ("eval_eval" in local_Insc_retval.keys()):
|
|
user['eval_eval'] = local_Insc_retval['eval_eval']
|
|
else:
|
|
user['eval_eval'] = "---"
|
|
|
|
|
|
if ("eval_status" in local_Insc_retval.keys()):
|
|
user['eval_status'] = local_Insc_retval['eval_status']
|
|
else:
|
|
user['eval_status'] = ""
|
|
|
|
|
|
if ("eval_note" in local_Insc_retval.keys()):
|
|
user['eval_note'] = local_Insc_retval['eval_note']
|
|
else:
|
|
user['eval_note'] = "---"
|
|
|
|
|
|
if ("eval_pedagogie" in local_Insc_retval.keys()):
|
|
user['eval_pedagogie'] = local_Insc_retval['eval_pedagogie']
|
|
else:
|
|
user['eval_pedagogie'] = ""
|
|
|
|
|
|
|
|
RetObject.append(mycommon.JSONEncoder().encode(user))
|
|
|
|
|
|
return True, RetObject
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(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 evaluations"
|
|
|
|
|
|
"""
|
|
Cette fonction permet d'annuler l'inscription à une formation.
|
|
# status -1 ==> Inscription annulée
|
|
"""
|
|
def CancelAttendeeInscription(diction):
|
|
try:
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'email', '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, " Les informations fournies ne sont pas correctes"
|
|
|
|
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 le recid du partenaire")
|
|
return False, "Impossible de récupérer le recid du partenaire"
|
|
|
|
data_mail = {}
|
|
# 1 - Recuperation des données de la formation
|
|
local_class = MYSY_GV.dbname['myclass'].find({'internal_url': str(diction['class_internal_url'])})
|
|
data_mail['title'] = local_class[0]['title']
|
|
class_title = local_class[0]['title']
|
|
|
|
# 2 - Recuperation des données de l'inscription
|
|
local_inscription = MYSY_GV.dbname['inscription'].find({'session_id': str(diction['session_id']),
|
|
'email': str(diction['email']),
|
|
'class_internal_url':str(diction['class_internal_url'])})
|
|
lms_class_code = ""
|
|
if ("lms_class_code" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_class_code']:
|
|
lms_class_code = local_inscription[0]['lms_class_code']
|
|
|
|
lms_user_id = ""
|
|
if ("lms_user_id" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_user_id']:
|
|
lms_user_id = local_inscription[0]['lms_user_id']
|
|
|
|
nom = ""
|
|
if ("nom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['nom']:
|
|
nom = local_inscription[0]['nom']
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['prenom']:
|
|
prenom = local_inscription[0]['prenom']
|
|
|
|
email = ""
|
|
if ("email" in local_inscription[0].keys()):
|
|
if local_inscription[0]['email']:
|
|
email = local_inscription[0]['email']
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_du']:
|
|
date_du = str(local_inscription[0]['date_du'])[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_au']:
|
|
date_au = str(local_inscription[0]['date_au'])[0:10]
|
|
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'_id': ObjectId(str(diction['session_id'])), 'class_internal_url': str(diction['class_internal_url']), 'valide':'1'})
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer les données de la session ")
|
|
return False, " Impossible de récupérer les données de la session "
|
|
|
|
# Annulation de l'inscription
|
|
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
|
|
ret_val2 = MYSY_GV.dbname['inscription'].find_one_and_update(
|
|
{'session_id': str(diction['session_id']), 'email': str(diction['email']), 'class_internal_url':str(diction['class_internal_url'])},
|
|
{"$set": {'status':'-1', 'inscription_refuse_date':now, 'date_update':now}},
|
|
return_document=ReturnDocument.AFTER,
|
|
upsert=False,
|
|
)
|
|
|
|
if( ret_val2 is None ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible d'annuler l'inscription ")
|
|
return False, " Impossible d'annuler l'inscription "
|
|
|
|
"""
|
|
Verification s'il y a une inscription LMS, au quel cas, on l'annule aussi
|
|
"""
|
|
|
|
return_message = ""
|
|
|
|
if( lms_user_id.strip() != ""):
|
|
# Il a une inscription à une formation dans le LMS, il faut l'annuler
|
|
new_diction = {}
|
|
new_diction['token'] = str(diction['token'])
|
|
new_diction['user_lms_id'] = str(lms_user_id)
|
|
new_diction['course_code'] = str(lms_class_code)
|
|
|
|
local_status, local_message = mys_lms.Remove_User_From_LMS_Class(new_diction)
|
|
if (local_status is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - WARNING : Impossible de supprimer l'inscription dans le LMS pour "+str( diction['email']) )
|
|
return_message = "Impossible de supprimer l'inscription dans le LMS pour : "+str( diction['email'])
|
|
|
|
email_data = {}
|
|
email_data['nom'] = nom
|
|
email_data['prenom'] = prenom
|
|
email_data['email'] = email
|
|
email_data['date_du'] = date_du
|
|
email_data['date_au'] = date_au
|
|
email_data['title'] = class_title
|
|
|
|
local_status, local_message = email_session.incription_training_cancelled_mail(email_data)
|
|
if( local_status is False ):
|
|
mycommon.myprint(str(
|
|
inspect.stack()[0][3]) + " - WARNING : Impossible d'envoyer le mail de notification pour " + str(
|
|
diction['email']))
|
|
return_message = return_message + str(" Impossible d'envoyer le mail de notification pour : " + str(diction['email']))
|
|
|
|
if( return_message.strip() != ""):
|
|
return True, return_message
|
|
|
|
return True, "L'inscription a été correctement annulée"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible d'annuler l'inscription"
|
|
|
|
|
|
|
|
"""
|
|
Cette fonction refuse une inscription, met jour le motif de refus
|
|
et envoie un email au participants
|
|
"""
|
|
def RefuseAttendeeInscription_with_motif(diction):
|
|
try:
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'email', 'inscription_id', 'motif']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - : La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Les informations fournies ne sont pas correctes"
|
|
|
|
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 le recid du partenaire")
|
|
return False, "Impossible de récupérer le recid du partenaire"
|
|
|
|
# 0 - Verifier de l'existance et de la validité de l'inscription (preinscription à refuser)
|
|
my_inscription_count = MYSY_GV.dbname['inscription'].count_documents({'_id':ObjectId(str(diction['inscription_id'])),
|
|
'partner_owner_recid':str(partner_recid)})
|
|
if( my_inscription_count <= 0 ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - L'identifiant d'inscription est invalide")
|
|
return False, "L'identifiant d'inscription est invalide"
|
|
|
|
|
|
data_mail = {}
|
|
|
|
# 2 - Recuperation des données de l'inscription
|
|
local_inscription = MYSY_GV.dbname['inscription'].find({'_id': ObjectId(str(diction['inscription_id'])),
|
|
'email': str(diction['email']),
|
|
'partner_owner_recid':str(partner_recid)})
|
|
lms_class_code = ""
|
|
if ("lms_class_code" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_class_code']:
|
|
lms_class_code = local_inscription[0]['lms_class_code']
|
|
|
|
lms_user_id = ""
|
|
if ("lms_user_id" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_user_id']:
|
|
lms_user_id = local_inscription[0]['lms_user_id']
|
|
|
|
nom = ""
|
|
if ("nom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['nom']:
|
|
nom = local_inscription[0]['nom']
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['prenom']:
|
|
prenom = local_inscription[0]['prenom']
|
|
|
|
email = ""
|
|
if ("email" in local_inscription[0].keys()):
|
|
if local_inscription[0]['email']:
|
|
email = local_inscription[0]['email']
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_du']:
|
|
date_du = str(local_inscription[0]['date_du'])[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_au']:
|
|
date_au = str(local_inscription[0]['date_au'])[0:10]
|
|
|
|
# 3 - Recuperation des données de la formation
|
|
local_class = MYSY_GV.dbname['myclass'].find({'internal_url': str(local_inscription[0]['class_internal_url']),
|
|
'partner_owner_recid':str(partner_recid)})
|
|
data_mail['title'] = local_class[0]['title']
|
|
class_title = local_class[0]['title']
|
|
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'_id': ObjectId(str(local_inscription[0]['session_id'])),
|
|
'valide':'1', 'partner_owner_recid':str(partner_recid)})
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer les données de la session ")
|
|
return False, " Impossible de récupérer les données de la session "
|
|
|
|
# Annulation de l'inscription
|
|
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
|
|
ret_val2 = MYSY_GV.dbname['inscription'].find_one_and_update(
|
|
{'_id': ObjectId( str(diction['inscription_id'])), 'email': str(diction['email'])},
|
|
{"$set": {'status':'-1', 'inscription_refuse_date':now, 'date_update':now,
|
|
'comment':str(diction['motif'])}},
|
|
return_document=ReturnDocument.AFTER,
|
|
upsert=False,
|
|
)
|
|
|
|
if( ret_val2 is None ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible d'annuler l'inscription ")
|
|
return False, " Impossible d'annuler l'inscription "
|
|
|
|
"""
|
|
Verification s'il y a une inscription LMS, au quel cas, on l'annule aussi
|
|
"""
|
|
|
|
return_message = ""
|
|
|
|
if( lms_user_id.strip() != ""):
|
|
# Il a une inscription à une formation dans le LMS, il faut l'annuler
|
|
new_diction = {}
|
|
new_diction['token'] = str(diction['token'])
|
|
new_diction['user_lms_id'] = str(lms_user_id)
|
|
new_diction['course_code'] = str(lms_class_code)
|
|
|
|
local_status, local_message = mys_lms.Remove_User_From_LMS_Class(new_diction)
|
|
if (local_status is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - WARNING : Impossible de supprimer l'inscription dans le LMS pour "+str( diction['email']) )
|
|
return_message = "Impossible de supprimer l'inscription dans le LMS pour : "+str( diction['email'])
|
|
|
|
email_data = {}
|
|
email_data['nom'] = nom
|
|
email_data['prenom'] = prenom
|
|
email_data['email'] = email
|
|
email_data['date_du'] = date_du
|
|
email_data['date_au'] = date_au
|
|
email_data['title'] = class_title
|
|
email_data['comment'] = str(diction['motif'])
|
|
|
|
local_status, local_message = email_session.incription_training_cancelled_mail(email_data)
|
|
if( local_status is False ):
|
|
mycommon.myprint(str(
|
|
inspect.stack()[0][3]) + " - WARNING : Impossible d'envoyer le mail de notification pour " + str(
|
|
diction['email']))
|
|
return_message = return_message + str(" Impossible d'envoyer le mail de notification pour : " + str(diction['email']))
|
|
|
|
if( return_message.strip() != ""):
|
|
return True, return_message
|
|
|
|
return True, "L'inscription a été correctement annulée"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible d'annuler l'inscription"
|
|
|
|
|
|
"""
|
|
Fontion de validation / acceptation d'un inscription
|
|
"""
|
|
def AcceptAttendeeInscription(diction):
|
|
try:
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'email', 'inscription_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, " Les informations fournies ne sont pas correctes"
|
|
|
|
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 le recid du partenaire")
|
|
return False, "Impossible de récupérer le recid du partenaire"
|
|
|
|
# 0 - Verifier de l'existance et de la validité de l'inscription (preinscription à refuser)
|
|
my_inscription_count = MYSY_GV.dbname['inscription'].count_documents({'_id':ObjectId(str(diction['inscription_id'])),
|
|
'partner_owner_recid':str(partner_recid)})
|
|
if( my_inscription_count <= 0 ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - L'identifiant d'inscription est invalide")
|
|
return False, "L'identifiant d'inscription est invalide"
|
|
|
|
|
|
data_mail = {}
|
|
|
|
# 2 - Recuperation des données de l'inscription
|
|
local_inscription = MYSY_GV.dbname['inscription'].find({'_id': ObjectId(str(diction['inscription_id'])),
|
|
'email': str(diction['email']),
|
|
'partner_owner_recid':str(partner_recid)})
|
|
lms_class_code = ""
|
|
if ("lms_class_code" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_class_code']:
|
|
lms_class_code = local_inscription[0]['lms_class_code']
|
|
|
|
lms_user_id = ""
|
|
if ("lms_user_id" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_user_id']:
|
|
lms_user_id = local_inscription[0]['lms_user_id']
|
|
|
|
nom = ""
|
|
if ("nom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['nom']:
|
|
nom = local_inscription[0]['nom']
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['prenom']:
|
|
prenom = local_inscription[0]['prenom']
|
|
|
|
email = ""
|
|
if ("email" in local_inscription[0].keys()):
|
|
if local_inscription[0]['email']:
|
|
email = local_inscription[0]['email']
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_du']:
|
|
date_du = str(local_inscription[0]['date_du'])[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_au']:
|
|
date_au = str(local_inscription[0]['date_au'])[0:10]
|
|
|
|
# 3 - Recuperation des données de la formation
|
|
local_class = MYSY_GV.dbname['myclass'].find({'internal_url': str(local_inscription[0]['class_internal_url']),
|
|
'partner_owner_recid':str(partner_recid)})
|
|
data_mail['title'] = local_class[0]['title']
|
|
class_title = local_class[0]['title']
|
|
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'_id': ObjectId(str(local_inscription[0]['session_id'])),
|
|
'valide':'1', 'partner_owner_recid':str(partner_recid)})
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer les données de la session ")
|
|
return False, " Impossible de récupérer les données de la session "
|
|
|
|
lms_class_code = ""
|
|
if( "lms_class_code" in local_class[0].keys() ):
|
|
if(len(str(local_class[0]['lms_class_code'])) > 2 ):
|
|
lms_class_code = str(local_class[0]['lms_class_code'])
|
|
|
|
""""
|
|
Inscription sur le LMS :
|
|
Si la formation associée à la session possede un code de formation lms 'lms_class_code'
|
|
|
|
Alors cela veut dire que c'est une formation qui est gérée avec le LMS de MYSY.
|
|
Donc l'inscription va generer :
|
|
1 - La creation du compte LMS participant
|
|
2 - L'inscription de l'utilisateur à la formation.
|
|
|
|
"""
|
|
return_message = ""
|
|
if( str(lms_class_code) != ""):
|
|
new_diction = {}
|
|
new_diction['token'] = diction['token']
|
|
new_diction['lastname'] = nom
|
|
new_diction['firstname'] = prenom
|
|
new_diction['email'] = email
|
|
new_diction['password'] = secrets.token_urlsafe(6)
|
|
new_diction['locked'] = "0"
|
|
new_diction['username'] = email
|
|
local_status, local_message, local_participant_lms_id = mys_lms.Create_MySy_LMS_Apprenant(new_diction)
|
|
|
|
if (local_status is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " WARNING : le compte LSM n'a pas été correctement crée")
|
|
return_message = return_message + " le compte LSM n'a pas été correctement crée. "
|
|
else:
|
|
# Mettre à jour la collection "inscription" en ajoutant local_participant_lms_id et et le mot de passe
|
|
print(" ### Mise à jour 'inscription' pour inscription_line_id = ", str(diction['inscription_id']),
|
|
" local_participant_lms_id = ", local_participant_lms_id, " str(new_diction['password'] ",
|
|
str(new_diction['password']))
|
|
local_ret_val = MYSY_GV.dbname['inscription'].find_one_and_update(
|
|
{'_id': ObjectId(str(diction['inscription_id']))},
|
|
{"$set": {'lms_user_id': str(local_participant_lms_id),
|
|
'lms_pwd': str(new_diction['password']),
|
|
'lms_class_code': str(lms_class_code)}
|
|
},
|
|
upsert=False,
|
|
return_document=ReturnDocument.AFTER
|
|
)
|
|
if (local_ret_val and local_ret_val['_id']):
|
|
mycommon.myprint(str(inspect.stack()[0][
|
|
3]) + " Le compte LMS du participant a été correctement mis à jour : local_ret_val['_id'] = " + str(
|
|
local_ret_val['_id']))
|
|
""""
|
|
A present, on va proceder à l'inscription à la formation
|
|
"""
|
|
print(" ### Debut de l'inscription au à la formation dans le LMS ")
|
|
new_diction = {}
|
|
new_diction['token'] = diction['token']
|
|
new_diction['user_lms_id'] = local_participant_lms_id
|
|
new_diction['course_code'] = lms_class_code
|
|
|
|
local_status2, local_message2 = mys_lms.Add_User_To_LMS_Class(new_diction)
|
|
if (local_status2 is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " WARNING : Impossbile de finaliser l'incription dans le LMS")
|
|
return_message = return_message + " Impossbile de finaliser l'incription dans le LMS. "
|
|
else:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " TOP, l'inscription dans le LMS a ete correctement faite")
|
|
|
|
else:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - WARNING : Impossible de mettre à jour le compte LMS ")
|
|
return_message = return_message + " Impossible de mettre à jour le compte LMS."
|
|
|
|
|
|
|
|
# date de validation de l'inscription
|
|
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
|
|
ret_val2 = MYSY_GV.dbname['inscription'].find_one_and_update(
|
|
{'_id': ObjectId( str(diction['inscription_id'])), 'email': str(diction['email'])},
|
|
{"$set": {'status':'1', 'inscription_validation_date':now, 'date_update':now
|
|
}},
|
|
return_document=ReturnDocument.AFTER,
|
|
upsert=False,
|
|
)
|
|
|
|
if( ret_val2 is None ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de valider l'inscription (1) ")
|
|
return False, " Impossible de valider l'inscription (2) "
|
|
|
|
"""
|
|
Verification s'il y a une inscription LMS, au quel cas, on l'annule aussi
|
|
"""
|
|
|
|
email_data = {}
|
|
email_data['nom'] = nom
|
|
email_data['prenom'] = prenom
|
|
email_data['email'] = email
|
|
email_data['date_du'] = date_du
|
|
email_data['date_au'] = date_au
|
|
email_data['title'] = class_title
|
|
email_data['partner_owner_recid'] = str(partner_recid)
|
|
|
|
if( "code_session" in local_session.keys()):
|
|
email_data['code_session'] = local_session['code_session']
|
|
else:
|
|
email_data['code_session'] = ""
|
|
|
|
if ("date_debut" in local_session.keys()):
|
|
email_data['date_debut'] = local_session['date_debut']
|
|
else:
|
|
email_data['date_debut'] = ""
|
|
|
|
if ("distantiel" in local_session.keys()):
|
|
email_data['distantiel'] = local_session['distantiel']
|
|
else:
|
|
email_data['distantiel'] = ""
|
|
|
|
if ("presentiel" in local_session.keys()):
|
|
email_data['presentiel'] = local_session['presentiel']
|
|
else:
|
|
email_data['presentiel'] = ""
|
|
|
|
if ("session_ondemande" in local_session.keys()):
|
|
email_data['session_ondemande'] = local_session['session_ondemande']
|
|
else:
|
|
email_data['session_ondemande'] = ""
|
|
|
|
if ("adresse" in local_session.keys()):
|
|
email_data['adresse'] = local_session['adresse']
|
|
else:
|
|
email_data['adresse'] = ""
|
|
|
|
if ("code_postal" in local_session.keys()):
|
|
email_data['code_postal'] = local_session['code_postal']
|
|
else:
|
|
email_data['code_postal'] = ""
|
|
|
|
if ("ville" in local_session.keys()):
|
|
email_data['ville'] = local_session['ville']
|
|
else:
|
|
email_data['ville'] = ""
|
|
|
|
if ("pays" in local_session.keys()):
|
|
email_data['pays'] = local_session['pays']
|
|
else:
|
|
email_data['pays'] = ""
|
|
|
|
if ("formateur" in local_session.keys()):
|
|
email_data['formateur'] = local_session['formateur']
|
|
else:
|
|
email_data['formateur'] = ""
|
|
|
|
if ("ville" in local_session.keys()):
|
|
email_data['ville'] = local_session['ville']
|
|
else:
|
|
email_data['ville'] = ""
|
|
|
|
|
|
local_status, local_message = email_session.incription_training_confirmation_mail(email_data)
|
|
if( local_status is False ):
|
|
mycommon.myprint(str(
|
|
inspect.stack()[0][3]) + " - WARNING : Impossible d'envoyer le mail de notification pour " + str(
|
|
diction['email']))
|
|
return_message = return_message + str(" Impossible d'envoyer le mail de notification pour : " + str(diction['email']))
|
|
|
|
if( return_message.strip() != ""):
|
|
return True, return_message
|
|
|
|
return True, "L'inscription a été correctement validée"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de valider l'inscription"
|
|
|
|
|
|
"""
|
|
Cette fonction supprime un stagiaire.
|
|
/!\ : seuls les preinscrit, ou les inscription annulés (donct status : 0 ou 1)
|
|
"""
|
|
def DeleteAttendeeInscription(diction):
|
|
try:
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'email', '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, " Les informations fournies ne sont pas correctes"
|
|
|
|
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 le recid du partenaire")
|
|
return False, "Impossible de récupérer le recid du partenaire"
|
|
|
|
data_mail = {}
|
|
# 1 - Recuperation des données de la formation
|
|
local_class = MYSY_GV.dbname['myclass'].find({'internal_url': str(diction['class_internal_url'])})
|
|
data_mail['title'] = local_class[0]['title']
|
|
class_title = local_class[0]['title']
|
|
|
|
# 2 - Recuperation des données de l'inscription
|
|
local_inscription = MYSY_GV.dbname['inscription'].find({'session_id': str(diction['session_id']),
|
|
'email': str(diction['email']), 'class_internal_url':str(diction['class_internal_url'])})
|
|
lms_class_code = ""
|
|
if ("lms_class_code" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_class_code']:
|
|
lms_class_code = local_inscription[0]['lms_class_code']
|
|
|
|
lms_user_id = ""
|
|
if ("lms_user_id" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_user_id']:
|
|
lms_user_id = local_inscription[0]['lms_user_id']
|
|
|
|
nom = ""
|
|
if ("nom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['nom']:
|
|
nom = local_inscription[0]['nom']
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['prenom']:
|
|
prenom = local_inscription[0]['prenom']
|
|
|
|
email = ""
|
|
if ("email" in local_inscription[0].keys()):
|
|
if local_inscription[0]['email']:
|
|
email = local_inscription[0]['email']
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_du']:
|
|
date_du = str(local_inscription[0]['date_du'])[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_au']:
|
|
date_au = str(local_inscription[0]['date_au'])[0:10]
|
|
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'_id': ObjectId(str(diction['session_id'])), 'class_internal_url': str(diction['class_internal_url']), 'valide':'1',})
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer les données de la session ")
|
|
return False, " Impossible de récupérer les données de la session "
|
|
|
|
|
|
# Verification que l'inscription existe et qu'elle est supprimable (donc status = 0 ou -1)
|
|
ret_val2_count = MYSY_GV.dbname['inscription'].count_documents(
|
|
{'session_id': str(diction['session_id']), 'email': str(diction['email']), 'class_internal_url':str(diction['class_internal_url'])},
|
|
)
|
|
|
|
if( ret_val2_count != 1):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de supprimer l'inscription. Il y a plusieurs inscription pour ce mail et cette formation")
|
|
return False, " Impossible de supprimer l'inscription (1)"
|
|
|
|
ret_val2 = MYSY_GV.dbname['inscription'].find_one(
|
|
{'session_id': str(diction['session_id']), 'email': str(diction['email']),
|
|
'class_internal_url': str(diction['class_internal_url'])},
|
|
)
|
|
|
|
if( "status" in ret_val2.keys()):
|
|
if( str(ret_val2['status']) != "0" and str(ret_val2['status']) != "-1"):
|
|
mycommon.myprint(str(inspect.stack()[0][
|
|
3]) + " - Impossible de supprimer l'inscription. L'inscription doit être annulée ou à l'etat 'préinscrit' avant d'être supprimé")
|
|
return False, " - Impossible de supprimer l'inscription. L'inscription doit être annulée ou à l'etat 'préinscrit' avant d'être supprimé"
|
|
|
|
detlete_retval = MYSY_GV.dbname['inscription'].delete_one(
|
|
{'session_id': str(diction['session_id']), 'email': str(diction['email']),
|
|
'class_internal_url': str(diction['class_internal_url'])},
|
|
)
|
|
|
|
return True, "L'inscription a été correctement supprimée"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de supprimer l'insciption "
|
|
|
|
|
|
|
|
"""
|
|
Cette fonction envoie l'email de connexion à la plateformation LMS
|
|
au participant
|
|
Cet email met en copie le responsable de la formation. ceci pour pouvoir renvoyer le mail au besoin
|
|
"""
|
|
def Send_LMS_Credentials_to_particpants(diction):
|
|
try:
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'email', '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, " Les informations fournies ne sont pas correctes"
|
|
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = diction['token']
|
|
|
|
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 le recid du partenaire")
|
|
return False, "Impossible de récupérer le recid du partenaire"
|
|
|
|
# 0 -Recuperation des données du partenaire
|
|
local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
|
|
if (local_status 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"
|
|
|
|
|
|
# Par defaut, lms_virtualhost_url = l'url racine.
|
|
lms_virtualhost_url = MYSY_GV.MYSY_LMS_URL
|
|
if ("lms_virtualhost_url" in my_partner.keys()):
|
|
if my_partner['lms_virtualhost_url']:
|
|
lms_virtualhost_url = my_partner['lms_virtualhost_url']
|
|
|
|
|
|
data_mail = {}
|
|
# 1 - Recuperation des données de la formation
|
|
local_class = MYSY_GV.dbname['myclass'].find({'internal_url': str(diction['class_internal_url'])})
|
|
data_mail['title'] = local_class[0]['title']
|
|
class_title = local_class[0]['title']
|
|
|
|
# 2 - Recuperation des données de l'inscription
|
|
local_inscription = MYSY_GV.dbname['inscription'].find({'session_id': str(diction['session_id']),
|
|
'email': str(diction['email'])})
|
|
lms_class_code = ""
|
|
if ("lms_class_code" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_class_code']:
|
|
lms_class_code = local_inscription[0]['lms_class_code']
|
|
|
|
lms_user_id = ""
|
|
if ("lms_user_id" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_user_id']:
|
|
lms_user_id = local_inscription[0]['lms_user_id']
|
|
|
|
lms_pwd = ""
|
|
if ("lms_pwd" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_pwd']:
|
|
lms_pwd = local_inscription[0]['lms_pwd']
|
|
|
|
nom = ""
|
|
if ("nom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['nom']:
|
|
nom = local_inscription[0]['nom']
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['prenom']:
|
|
prenom = local_inscription[0]['prenom']
|
|
|
|
email = ""
|
|
if ("email" in local_inscription[0].keys()):
|
|
if local_inscription[0]['email']:
|
|
email = local_inscription[0]['email']
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_du']:
|
|
date_du = str(local_inscription[0]['date_du'])[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_au']:
|
|
date_au = str(local_inscription[0]['date_au'])[0:10]
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'_id': ObjectId(str(diction['session_id'])),
|
|
'class_internal_url': str(diction['class_internal_url']), 'valide':'1',})
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer les données de la session ")
|
|
return False, " Impossible de récupérer les données de la session "
|
|
|
|
|
|
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
return_message = ""
|
|
email_data = {}
|
|
email_data['nom'] = nom
|
|
email_data['prenom'] = prenom
|
|
email_data['email'] = email
|
|
email_data['date_du'] = date_du
|
|
email_data['date_au'] = date_au
|
|
email_data['title'] = class_title
|
|
|
|
email_data['login'] = email
|
|
email_data['pwd'] = lms_pwd
|
|
email_data['lms_url'] = str(lms_virtualhost_url)
|
|
email_data['course_owner_email'] = my_partner['email']
|
|
email_data['partner_recid'] = my_partner['recid']
|
|
|
|
#split_mail_tab = str(email).split('@')
|
|
#email_data['login'] = split_mail_tab[0]
|
|
|
|
|
|
local_status, local_message = email_session.LMS_Credential_Sending_mail(email_data)
|
|
if (local_status is False):
|
|
mycommon.myprint(str(
|
|
inspect.stack()[0][3]) + " - WARNING : Impossible d'envoyer le mail de notification pour " + str(
|
|
diction['email']))
|
|
return_message = return_message + str(
|
|
" Impossible d'envoyer le mail de notification pour : " + str(diction['email']))
|
|
|
|
if (return_message.strip() != ""):
|
|
return True, return_message
|
|
|
|
|
|
return True, " Les informations de connexion ont été correctement envoyées"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible d'envoyer les informations de connexion à la plateforme LMS"
|
|
|
|
"""
|
|
Cette fonction ajoute une image de profil d'un stagaire
|
|
"""
|
|
def Update_Stagiaire_Image(file_img=None, Folder=None, diction=None):
|
|
try:
|
|
|
|
# Dictionnaire des champs utilisables
|
|
'''
|
|
# 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', 'file_img_recid', 'class_internal_url', 'session_id', 'email' ]
|
|
|
|
|
|
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é ")
|
|
return False, " Le champ '" + val + "' n'est pas accepté "
|
|
|
|
'''
|
|
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 "
|
|
|
|
# recuperation des paramettre
|
|
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
|
|
|
|
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']
|
|
|
|
email = ""
|
|
if ("email" in diction.keys()):
|
|
if diction['email']:
|
|
email = diction['email']
|
|
|
|
|
|
## Recuperation de l'"_id" du stagiaire -- Exceptionnement on va mettre dans "_id" dans le 'related_collection_recid'
|
|
local_retval = MYSY_GV.dbname['inscription'].find_one({'class_internal_url':str(class_internal_url),
|
|
'session_id':str(session_id), 'email':str(email) })
|
|
if( local_retval is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " : Le stagiaire "+str(email)+" n'est pas reconnu pour la session bb"+str(str(session_id)) )
|
|
return False, " Le stagiaire n'est pas reconnu "
|
|
|
|
|
|
"""
|
|
A present que le partenaire est mis à jour / créé, on va mettre à jour les image logo et image cachet s'il y en a
|
|
"""
|
|
if( file_img ):
|
|
recordimage_diction = {}
|
|
recordimage_diction['token'] = diction['token']
|
|
recordimage_diction['related_collection'] = "inscription"
|
|
recordimage_diction['type_img'] = "user"
|
|
recordimage_diction['related_collection_recid'] = str(local_retval['_id'])
|
|
recordimage_diction['image_recid'] = diction['file_img_recid']
|
|
|
|
print(" ### recordimage_diction stagaire = ", recordimage_diction)
|
|
local_status, local_message = mycommon.recordClassImage_v2(file_img, MYSY_GV.upload_folder, recordimage_diction)
|
|
if( local_status is False):
|
|
return local_status, local_message
|
|
|
|
return True, "L'image du stagiaire a été correctement enregistré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 d'enregistrer l'image du stagiaire"
|
|
|
|
|
|
|
|
""" Recuperation de l'image d'un stagiaire
|
|
|
|
/!\ important : on prend le 'related_collection_recid' comme le '_id' de la collection inscription
|
|
"""
|
|
def getRecodedStagiaireImage_from_front(diction=None):
|
|
try:
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['token', 'class_internal_url', 'session_id', 'email']
|
|
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, requete annulée")
|
|
return False, " Impossible de récupérer les informations"
|
|
|
|
'''
|
|
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', 'session_id', 'email']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - : La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Impossible de récupérer les informations"
|
|
|
|
|
|
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']
|
|
|
|
session_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
session_id = diction['session_id']
|
|
|
|
email = ""
|
|
if ("email" in diction.keys()):
|
|
if diction['email']:
|
|
email = diction['email']
|
|
|
|
## Recuperation de l'"_id" du stagiaire -- Exceptionnement on va mettre dans "_id" dans le 'related_collection_recid'
|
|
local_retval = MYSY_GV.dbname['inscription'].find_one({'class_internal_url': str(class_internal_url),
|
|
'session_id': str(session_id),
|
|
'email': str(email)})
|
|
if (local_retval is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " : Le stagiaire " + str(
|
|
email) + " n'est pas reconnu pour la session aa" + str(str(session_id)))
|
|
return False, " Le stagiaire n'est pas reconnu "
|
|
|
|
|
|
qery_images = {'locked': '0', 'valide': '1', 'related_collection': 'inscription',
|
|
'related_collection_recid': str(local_retval['_id'])}
|
|
|
|
print(" ### qery_images = ", qery_images)
|
|
|
|
RetObject = []
|
|
partner_images = {}
|
|
# Recuperation des image 'logo' et 'cachet' si le partenaire en a
|
|
for retVal in MYSY_GV.dbname['mysy_images'].find(qery_images):
|
|
if ('type_img' in retVal.keys()):
|
|
if (retVal['type_img'] == "user"):
|
|
partner_images['logo_img'] = retVal['img'].decode()
|
|
partner_images['logo_img_recid'] = retVal['recid']
|
|
|
|
|
|
RetObject.append(mycommon.JSONEncoder().encode(partner_images))
|
|
|
|
|
|
return True, RetObject
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de recupérer l'image du stagiaire"
|
|
|
|
|
|
"""
|
|
Suppresion d'un image d'un stagiaire
|
|
"""
|
|
def DeleteImage_Stagiaire_v2(diction=None):
|
|
try:
|
|
|
|
# Dictionnaire des champs utilisables
|
|
field_list = ['token', 'image_recid', ]
|
|
incom_keys = diction.keys()
|
|
|
|
'''
|
|
# 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.
|
|
'''
|
|
for val in incom_keys:
|
|
if str(val).lower() not in str(field_list).lower():
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas accepté dans cette API")
|
|
return False, " Impossible de se connecter"
|
|
|
|
'''
|
|
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', 'image_recid']
|
|
for val in field_list_obligatoire:
|
|
if str(val).lower() not in diction:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " La valeur '" + val + "' n'est pas presente dans liste des champs")
|
|
return False, "Impossible de se connecter"
|
|
|
|
mydata = {}
|
|
mytoken = ""
|
|
|
|
# recuperation des paramettre
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = diction['token']
|
|
|
|
image_recid = ""
|
|
if ("image_recid" in diction.keys()):
|
|
if diction['image_recid']:
|
|
image_recid = diction['image_recid']
|
|
|
|
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
|
|
if (local_status is not True):
|
|
return local_status, my_partner
|
|
|
|
# " Lecture du fichier "
|
|
# print(" Lecture du fichier : " + saved_file + ". le token est :" + str(mytoken))
|
|
nb_line = 0
|
|
coll_name = MYSY_GV.dbname['mysy_images']
|
|
|
|
query_delete = {"recid": image_recid,}
|
|
|
|
|
|
ret_val = coll_name.delete_one({"recid": image_recid,}, )
|
|
|
|
|
|
|
|
print(" ### recordClassImage_v2 :L'image a été correctement supprimée ")
|
|
return True, "L'image a été correctement supprimée"
|
|
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de supprimer l'image "
|
|
|
|
"""
|
|
Cette fonction récupérer la liste des stagiaire d'un partenaire.
|
|
On y ajoute la formation concernée
|
|
"""
|
|
def Get_Statgaire_List_Partner_with_filter(diction):
|
|
try:
|
|
field_list = ['token', 'class_internal_url', 'code_session', 'status', 'email', 'nom', 'class_title', 'code_session','client_nom']
|
|
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, "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']
|
|
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 "
|
|
|
|
|
|
|
|
"""
|
|
Etape 1 : si on a le champ 'code session' saisie par l'utilisateur,
|
|
alors on va commencer par aller cherche toutes les session avec un regex de la valeur saisie filter sur le partner_recid
|
|
|
|
"""
|
|
filt_session_id = {}
|
|
list_session_id = []
|
|
if ("code_session" in diction.keys()):
|
|
filt_code_session = {'code_session': {'$regex': str(diction['code_session']), "$options": "i"}}
|
|
"""qry_list_session_id = { { '$and' :[ {'code_session': {'$regex': str(diction['code_session']), "$options": "i"}},
|
|
{'partner_owner_recid': str(partner_recid)} ]}, {'_id':1}}
|
|
"""
|
|
|
|
qry_list_session_id = {"$and": [{'code_session': {'$regex': str(diction['code_session']), "$options": "i"}},
|
|
{'partner_owner_recid': str(partner_recid)}]}
|
|
|
|
print(" ### qry_list_session_id aa = ", qry_list_session_id)
|
|
list_session_id_count = MYSY_GV.dbname['session_formation'].count_documents(qry_list_session_id)
|
|
|
|
if( list_session_id_count <= 0 ):
|
|
# Aucune session
|
|
return True, []
|
|
|
|
for val in MYSY_GV.dbname['session_formation'].find(qry_list_session_id):
|
|
list_session_id.append(str(val['_id']))
|
|
|
|
print(" ### liste des Id des sessions eligible list_session_id = ", list_session_id)
|
|
filt_session_id = {'session_id': {'$in': list_session_id, }}
|
|
|
|
filt_class_title = {}
|
|
if ("class_title" in diction.keys()):
|
|
filt_class_title = {'title': {'$regex': str(diction['class_title']), "$options": "i"}}
|
|
|
|
filt_class_internal_url = {}
|
|
if ("class_internal_url" in diction.keys()):
|
|
filt_class_internal_url = {
|
|
'class_internal_url': {'$regex': str(diction['class_internal_url']), "$options": "i"}}
|
|
|
|
filt_email = {}
|
|
if ("email" in diction.keys()):
|
|
filt_email = {'email': {'$regex': str(diction['email']), "$options": "i"}}
|
|
|
|
filt_nom = {}
|
|
if ("nom" in diction.keys()):
|
|
filt_nom = {'nom': {'$regex': str(diction['nom']), "$options": "i"}}
|
|
|
|
filt_class_partner_recid = {'partner_owner_recid': str(partner_recid)}
|
|
|
|
|
|
# -----
|
|
|
|
filt_client_nom = {}
|
|
sub_filt_client_nom = {}
|
|
Lists_partner_client_id = []
|
|
if ("client_nom" in diction.keys()):
|
|
sub_filt_client_nom = {'nom': {'$regex': str(diction['client_nom']), "$options": "i"},
|
|
'partner_recid': str(partner_recid), 'valide': '1', 'locked': '0'}
|
|
# Recuperation des '_id' des clients dont le nom match en regexp
|
|
# print(" ### sub_filt_client_nom = ", sub_filt_client_nom)
|
|
for List_Client_Data in MYSY_GV.dbname['partner_client'].find(sub_filt_client_nom, {'_id': 1}):
|
|
Lists_partner_client_id.append(str(List_Client_Data['_id']))
|
|
|
|
filt_client_nom = {'client_rattachement_id': {'$in': Lists_partner_client_id, }}
|
|
# print(' ### filt_client_nom = ', filt_client_nom)
|
|
|
|
|
|
#----
|
|
|
|
|
|
query = [{'$match':{ '$and' : [ filt_class_internal_url, filt_session_id, filt_email, filt_nom, filt_client_nom, {'partner_owner_recid':str(partner_recid)}] } },
|
|
{'$lookup':
|
|
{
|
|
'from': 'myclass',
|
|
'localField': 'class_internal_url',
|
|
'foreignField': 'internal_url',
|
|
'pipeline': [{'$match':{ '$and' : [ filt_class_title, filt_class_partner_recid] } }, {'$project': {'title': 1, 'domaine': 1,
|
|
'duration': 1,
|
|
'duration_unit': 1}}],
|
|
'as': 'myclass_collection'
|
|
}
|
|
}
|
|
]
|
|
print("#### Get_Statgaire_List_Partner_with_filter : query = ", query)
|
|
RetObject = []
|
|
cpt = 1
|
|
for retVal in MYSY_GV.dbname['inscription'].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['session_id'] = retVal['session_id']
|
|
val['class_internal_url'] = retVal['class_internal_url']
|
|
|
|
val['nom'] = retVal['nom']
|
|
val['prenom'] = retVal['prenom']
|
|
|
|
val['email'] = retVal['email']
|
|
|
|
|
|
if( "modefinancement" in retVal.keys()):
|
|
val['modefinancement'] = retVal['modefinancement']
|
|
else:
|
|
val['modefinancement'] = ""
|
|
|
|
if ("opco" in retVal.keys()):
|
|
val['opco'] = retVal['opco']
|
|
else:
|
|
val['opco'] = ""
|
|
|
|
|
|
if ("employeur" in retVal.keys()):
|
|
val['employeur'] = retVal['employeur']
|
|
else:
|
|
val['employeur'] = ""
|
|
|
|
if ("telephone" in retVal.keys()):
|
|
val['telephone'] = retVal['telephone']
|
|
else:
|
|
val['telephone'] = ""
|
|
|
|
|
|
val['status'] = retVal['status']
|
|
|
|
val['title'] = retVal['myclass_collection'][0]['title']
|
|
val['domaine'] = retVal['myclass_collection'][0]['domaine']
|
|
|
|
# Recuperation des informations de la session
|
|
local_qry = {'_id':ObjectId(retVal['session_id']), 'valide':'1'}
|
|
|
|
#print(" #### local_qry zzz = ", local_qry)
|
|
|
|
count_session = MYSY_GV.dbname['session_formation'].count_documents(local_qry)
|
|
|
|
|
|
client_rattachement_id = ""
|
|
client_rattachement_nom = ""
|
|
# Si il a un client rattacher, recuperation des information du client
|
|
|
|
#print(" ### retVal = ", retVal )
|
|
if( "client_rattachement_id" in retVal.keys()):
|
|
if( retVal['client_rattachement_id'] and str(retVal['client_rattachement_id'] ) != 'undefined'):
|
|
client_retval = MYSY_GV.dbname['partner_client'].find_one({'id':ObjectId( retVal['client_rattachement_id']),
|
|
'valide':'1', 'locked':'0'})
|
|
|
|
if( client_retval is not None):
|
|
client_rattachement_id= client_retval['_id']
|
|
client_rattachement_nom = client_retval['nom']
|
|
|
|
val['client_rattachement_id'] = client_rattachement_id
|
|
val['client_rattachement_nom'] = client_rattachement_nom
|
|
|
|
if(count_session != 1 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " - Impossible de récupérer la liste des stagiaires, Il y a une incohérence sur la session : " + str(
|
|
retVal['session_id']))
|
|
return False, "Impossible de récupérer la liste des stagiaires, Les informations d'identification sont incorrectes. Il y a une incohérence sur la session : " + str(
|
|
retVal['session_id'])
|
|
|
|
|
|
#qry2 = {'class_internal_url':str(retVal['class_internal_url']), 'code_session':str(retVal['session_id']), 'valide':'1'}
|
|
#print(" ### qry 2 =", qry2)
|
|
session_retval = MYSY_GV.dbname['session_formation'].find_one({'_id':ObjectId(str(retVal['session_id'])), 'valide':'1'})
|
|
|
|
if ("code_session" in session_retval.keys()):
|
|
val['code_session'] = str(session_retval['code_session'])
|
|
else:
|
|
val['code_session'] = ""
|
|
|
|
|
|
if ("date_debut" in session_retval.keys()):
|
|
val['date_du'] = str(session_retval['date_debut'])[0:10]
|
|
else:
|
|
val['date_du'] = ""
|
|
|
|
if ("date_fin" in session_retval.keys()):
|
|
val['date_au'] = str(session_retval['date_fin'])[0:10]
|
|
else:
|
|
val['date_au'] = ""
|
|
|
|
if ("code_postal" in session_retval.keys()):
|
|
val['code_postal'] = session_retval['code_postal']
|
|
else:
|
|
val['code_postal'] = ""
|
|
|
|
if ("prix_session" in session_retval.keys()):
|
|
val['price'] = session_retval['prix_session']
|
|
else:
|
|
val['price'] = ""
|
|
|
|
if ("presentiel" in session_retval.keys()):
|
|
val['presentiel'] = session_retval['presentiel']
|
|
else:
|
|
val['presentiel'] = "0"
|
|
|
|
if ("distantiel" in session_retval.keys()):
|
|
val['distantiel'] = session_retval['distantiel']
|
|
else:
|
|
val['distantiel'] = "0"
|
|
|
|
if ("session_ondemande" in session_retval.keys()):
|
|
val['session_ondemande'] = session_retval['session_ondemande']
|
|
else:
|
|
val['session_ondemande'] = "0"
|
|
|
|
|
|
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 stagiaires"
|
|
|
|
|
|
"""
|
|
Cette fonction prend '_id' d'une ligne et retour les information de l'inscription associé.
|
|
|
|
Un controle sera fait avec le partner_recid
|
|
"""
|
|
|
|
def GetAttendeeDetail_perSession_from_line_id(diction):
|
|
try:
|
|
field_list_obligatoire = [ 'token', '_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 les informations detaillées"
|
|
|
|
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"
|
|
|
|
|
|
# Recuperation du recid du partenaire
|
|
partner_recid = mycommon.get_parnter_recid_from_token(str(my_token))
|
|
if partner_recid is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer le recid du partenaire")
|
|
return False, " Les informations d'identification sont invalides"
|
|
|
|
RetObject = []
|
|
|
|
qry_filter = {'_id':ObjectId(str(diction['_id'])),'partner_owner_recid':str(partner_recid),}
|
|
|
|
|
|
pipe_qry = ([{'$match':qry_filter},
|
|
{'$lookup':
|
|
{
|
|
'from': 'session_formation',
|
|
'let': {'session_id': "$session_id", 'class_internal_url': '$class_internal_url', 'partner_owner_recid':'$partner_owner_recid'},
|
|
|
|
'pipeline': [
|
|
{'$match':
|
|
{'$expr':
|
|
{'$and':
|
|
[
|
|
{'$eq': ['$_id', { '$toObjectId': '$$session_id' }]},
|
|
{'$eq': ["$valide", "1"]},
|
|
{'$eq': ["$partner_owner_recid", '$$partner_owner_recid']}
|
|
]
|
|
}
|
|
}
|
|
},
|
|
|
|
],
|
|
'as': 'inscription_collectoin'
|
|
}
|
|
},
|
|
|
|
])
|
|
|
|
|
|
print(" ### GetAttendeeDetail_perSession_from_line_id ici pipe_qry = ",pipe_qry)
|
|
# Recuperation des infos de la formation
|
|
"""local_Insc_retval = MYSY_GV.dbname['inscription'].find_one({'session_id':str(diction['session_id']),
|
|
'email':str(diction['attendee_email']),
|
|
'class_internal_url':str(diction['internal_url']),})
|
|
"""
|
|
|
|
|
|
for local_Insc_retval in MYSY_GV.dbname['inscription'].aggregate(pipe_qry) :
|
|
|
|
#print(" ### local_Insc_retval laa== ", local_Insc_retval)
|
|
|
|
if( local_Insc_retval is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer le recid du partenaire (2)")
|
|
return False, " Les informations d'identifier la session (2) "
|
|
|
|
if ('inscription_collectoin' in local_Insc_retval.keys() and len(local_Insc_retval['inscription_collectoin']) > 0):
|
|
my_retrun_dict = {}
|
|
|
|
if ("session_id" in local_Insc_retval.keys()):
|
|
my_retrun_dict['session_id'] = local_Insc_retval['session_id']
|
|
|
|
|
|
if ("code_session" in local_Insc_retval['inscription_collectoin'][0].keys()):
|
|
my_retrun_dict['code_session'] = str(local_Insc_retval['inscription_collectoin'][0]['code_session'])
|
|
|
|
if ("date_debut" in local_Insc_retval['inscription_collectoin'][0].keys()):
|
|
my_retrun_dict['date_du'] = str(local_Insc_retval['inscription_collectoin'][0]['date_debut'])[0:10]
|
|
|
|
if ("date_fin" in local_Insc_retval['inscription_collectoin'][0].keys()):
|
|
my_retrun_dict['date_au'] = str(local_Insc_retval['inscription_collectoin'][0]['date_fin'])[0:10]
|
|
|
|
if ("ville" in local_Insc_retval.keys()):
|
|
my_retrun_dict['ville'] = local_Insc_retval['ville']
|
|
|
|
if ("code_postal" in local_Insc_retval.keys()):
|
|
my_retrun_dict['code_postal'] = local_Insc_retval['code_postal']
|
|
|
|
if ("certification_send_date" in local_Insc_retval.keys()):
|
|
if (str(local_Insc_retval['certification_send_date'])):
|
|
my_retrun_dict['certification_send_date'] = str(local_Insc_retval['certification_send_date'])[0:10]
|
|
|
|
local_adresse = ""
|
|
if ("adresse" in local_Insc_retval.keys()):
|
|
local_adresse = local_Insc_retval['adresse']
|
|
my_retrun_dict['adresse'] = local_adresse
|
|
|
|
local_nom = ""
|
|
if ("nom" in local_Insc_retval.keys()):
|
|
local_nom = local_Insc_retval['nom']
|
|
my_retrun_dict['nom'] = local_nom
|
|
|
|
local_prenom = ""
|
|
if ("prenom" in local_Insc_retval.keys()):
|
|
local_prenom = local_Insc_retval['prenom']
|
|
my_retrun_dict['prenom'] = local_prenom
|
|
|
|
local_employeur = ""
|
|
if ("employeur" in local_Insc_retval.keys()):
|
|
local_employeur = local_Insc_retval['employeur']
|
|
my_retrun_dict['employeur'] = local_employeur
|
|
|
|
local_telephone = ""
|
|
if ("telephone" in local_Insc_retval.keys()):
|
|
local_telephone = local_Insc_retval['telephone']
|
|
my_retrun_dict['telephone'] = local_telephone
|
|
|
|
local_email = ""
|
|
if ("email" in local_Insc_retval.keys()):
|
|
local_email = local_Insc_retval['email']
|
|
my_retrun_dict['email'] = local_email
|
|
|
|
local_modefinancement = ""
|
|
if ("modefinancement" in local_Insc_retval.keys()):
|
|
local_modefinancement = local_Insc_retval['modefinancement']
|
|
my_retrun_dict['modefinancement'] = local_modefinancement
|
|
|
|
local_opco = ""
|
|
if ("opco" in local_Insc_retval.keys()):
|
|
local_opco = local_Insc_retval['opco']
|
|
my_retrun_dict['opco'] = local_opco
|
|
|
|
local_class_internal_url = ""
|
|
if ("class_internal_url" in local_Insc_retval.keys()):
|
|
local_class_internal_url = local_Insc_retval['class_internal_url']
|
|
my_retrun_dict['class_internal_url'] = local_class_internal_url
|
|
|
|
local_status = ""
|
|
if ("status" in local_Insc_retval.keys()):
|
|
local_status = local_Insc_retval['status']
|
|
my_retrun_dict['status'] = local_status
|
|
|
|
local_price = ""
|
|
if ("price" in local_Insc_retval.keys()):
|
|
local_price = local_Insc_retval['price']
|
|
my_retrun_dict['price'] = local_price
|
|
|
|
local_inscription_validation_date = ""
|
|
if ("inscription_validation_date" in local_Insc_retval.keys()):
|
|
local_inscription_validation_date = local_Insc_retval['inscription_validation_date']
|
|
my_retrun_dict['inscription_validation_date'] = local_inscription_validation_date
|
|
|
|
if ("eval_eval" in local_Insc_retval.keys()):
|
|
if (str(local_Insc_retval['eval_eval'])):
|
|
my_retrun_dict['eval_eval'] = local_Insc_retval['eval_eval']
|
|
|
|
if ("eval_note" in local_Insc_retval.keys()):
|
|
if (str(local_Insc_retval['eval_note'])):
|
|
my_retrun_dict['eval_note'] = local_Insc_retval['eval_note']
|
|
|
|
if ("eval_pedagogie" in local_Insc_retval.keys()):
|
|
if (str(local_Insc_retval['eval_pedagogie'])):
|
|
my_retrun_dict['eval_pedagogie'] = local_Insc_retval['eval_pedagogie']
|
|
|
|
if ("eval_date" in local_Insc_retval.keys()):
|
|
if (str(local_Insc_retval['eval_date'])):
|
|
my_retrun_dict['eval_date'] = str(local_Insc_retval['eval_date'])[0:10]
|
|
|
|
client_rattachement_id = ""
|
|
client_rattachement_nom = ""
|
|
if ("client_rattachement_id" in local_Insc_retval.keys()):
|
|
if( local_Insc_retval['client_rattachement_id'] and str(local_Insc_retval['client_rattachement_id']) != 'undefined' ):
|
|
local_client_retval_data = MYSY_GV.dbname['partner_client'].find_one({'_id': ObjectId(str(local_Insc_retval['client_rattachement_id'])),
|
|
'valide': '1', 'locked': '0'}, {'_id':1, 'nom':1})
|
|
|
|
if( local_client_retval_data is not None):
|
|
client_rattachement_id = local_client_retval_data['_id']
|
|
client_rattachement_nom = local_client_retval_data['nom']
|
|
|
|
my_retrun_dict['client_rattachement_id'] = client_rattachement_id
|
|
my_retrun_dict['client_rattachement_nom'] = client_rattachement_nom
|
|
|
|
|
|
v = local_Insc_retval['_id'].generation_time
|
|
my_retrun_dict['created_date'] = str(v.strftime("%d/%m/%Y"))
|
|
|
|
# Recuperation des informations de la formation
|
|
local_formation = MYSY_GV.dbname['myclass'].find_one({'internal_url':str(local_Insc_retval['class_internal_url'])})
|
|
|
|
if local_formation is None or local_formation['_id'] is None:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer les informations de la formation ")
|
|
return False, " Impossible de récupérer les informations de la formation"
|
|
|
|
|
|
|
|
my_retrun_dict['class_title'] = local_formation['title']
|
|
|
|
RetObject.append(mycommon.JSONEncoder().encode(my_retrun_dict))
|
|
|
|
|
|
return True, RetObject
|
|
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de récupérer les informations detaillées"
|
|
|