""" 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('
', '').replace('
', '').replace("\r\n", '