2884 lines
121 KiB
Python
2884 lines
121 KiB
Python
"""
|
|
Ce fichier permets de créer les inscription des stagiaires à une formation
|
|
"""
|
|
import pymongo
|
|
from pymongo import MongoClient
|
|
import json
|
|
from bson import ObjectId
|
|
import re
|
|
from datetime import datetime
|
|
import prj_common as mycommon
|
|
import secrets
|
|
import inspect
|
|
import sys, os
|
|
import csv
|
|
import pandas as pd
|
|
from pymongo import ReturnDocument
|
|
import GlobalVariable as MYSY_GV
|
|
from math import isnan
|
|
import GlobalVariable as MYSY_GV
|
|
from datetime import timedelta
|
|
import email_inscription_mgt as email_session
|
|
from flask import send_file
|
|
import re
|
|
from xhtml2pdf import pisa
|
|
import jinja2
|
|
import ftplib
|
|
import pysftp
|
|
import email_mgt as email_mgt
|
|
import lms_chamilo.mysy_lms as mys_lms
|
|
|
|
"""
|
|
Enregistrement d'un stagiaire
|
|
|
|
Voici les valeurs possibles du statut d'un stagiaire
|
|
# 0 ==> Preinscription
|
|
# 1 ==> Inscription validée
|
|
# -1 ==> Inscription annulée
|
|
|
|
|
|
"""
|
|
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']
|
|
incom_keys = diction.keys()
|
|
for val in incom_keys:
|
|
if val not in field_list:
|
|
mycommon.myprint(str(inspect.stack()[0][
|
|
3]) + " - Creation partner account : Le champ '" + val + "' n'est pas autorisé, Creation partenaire annulée")
|
|
return False, "Impossible de créer 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()
|
|
|
|
"""
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = str(diction['token']).strip()
|
|
|
|
|
|
partner_recid = mycommon.get_parnter_recid_from_token(mytoken)
|
|
if (partner_recid is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer les données du partenaire ")
|
|
return False, "Impossible de recuperer les données du partenaire "
|
|
"""
|
|
|
|
"""
|
|
Recuperation des info de la session de formation
|
|
"""
|
|
|
|
for tmp_val in MYSY_GV.dbname['session_formation'].find({"formation_session_id":str(session_id)}):
|
|
mydata['date_du'] = tmp_val['date_debut']
|
|
mydata['date_au'] = tmp_val['date_fin']
|
|
|
|
if ("ville" in tmp_val.keys()):
|
|
if tmp_val['ville']:
|
|
mydata['ville'] = tmp_val['ville']
|
|
|
|
if ("code_postal" in tmp_val.keys()):
|
|
if tmp_val['code_postal']:
|
|
mydata['code_postal'] = tmp_val['code_postal']
|
|
|
|
if ("adresse" in tmp_val.keys()):
|
|
if tmp_val['adresse']:
|
|
mydata['adresse'] = tmp_val['adresse']
|
|
|
|
|
|
print(" #### mydata = "+str(mydata))
|
|
|
|
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 ("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,}\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 = "0" # 0 ==> Preinscription, par defaut
|
|
if ("status" in diction.keys()):
|
|
if diction['status']:
|
|
new_status = str(diction['status']).strip()
|
|
mydata['status'] = str(new_status)
|
|
|
|
new_price = "0" # 0 ==> par defaut
|
|
if ("price" in diction.keys()):
|
|
if diction['price']:
|
|
new_price = str(diction['price']).strip()
|
|
mydata['price'] = new_price
|
|
|
|
coll_inscription = MYSY_GV.dbname['inscription']
|
|
|
|
## Verification si cette adresse n'est pas deja inscrite à cette session
|
|
# print(" myquery pr demo_account = " + str(myquery))
|
|
tmp = coll_inscription.count_documents({'email':str(mydata['email']),
|
|
'session_id':str( mydata['session_id']),
|
|
'class_internal_url':str(mydata['class_internal_url'])})
|
|
|
|
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 "
|
|
|
|
ret_val = coll_inscription.insert_one(mydata)
|
|
|
|
inserted_id = ret_val.inserted_id
|
|
if( inserted_id ):
|
|
# Le stagaire a bien ete inseré, on declenche l'envoi des emaisl
|
|
print(" ### l'inscription est ok, il faut declenché l'envoi des email")
|
|
## 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']
|
|
|
|
print(" ### l'inscription est ok, il faut declenché 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']) + " ")
|
|
|
|
|
|
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éé"
|
|
|
|
|
|
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
|
|
|
|
/!\ 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']
|
|
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']
|
|
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"
|
|
|
|
|
|
myemail = ""
|
|
if ("email" in diction.keys()):
|
|
if diction['email']:
|
|
myemail = str(diction['email']).strip()
|
|
query_key['email'] = str(diction['email']).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 "
|
|
|
|
|
|
|
|
mydata = {}
|
|
user_nom = ""
|
|
|
|
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()):
|
|
if diction['price']:
|
|
mydata['price'] = str(diction['price']).strip()
|
|
|
|
if ("employeur" in diction.keys()):
|
|
if diction['employeur']:
|
|
mydata['employeur'] = str(diction['employeur']).strip()
|
|
|
|
user_prenom = ""
|
|
if ("prenom" in diction.keys()):
|
|
if diction['prenom']:
|
|
mydata['prenom'] = str(diction['prenom']).strip()
|
|
user_prenom = str(diction['prenom']).strip()
|
|
|
|
if ("telephone" in diction.keys()):
|
|
if diction['telephone']:
|
|
mydata['telephone'] = str(diction['telephone']).strip()
|
|
|
|
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 ("price" in diction.keys()):
|
|
if diction['price']:
|
|
mydata['price'] = str(diction['price']).strip()
|
|
|
|
new_status = ""
|
|
if ("status" in diction.keys()):
|
|
if diction['status']:
|
|
mydata['status'] = str(diction['status']).strip()
|
|
new_status = str(diction['status']).strip()
|
|
|
|
|
|
if ("comment" in diction.keys()):
|
|
if diction['comment']:
|
|
mydata['comment'] = str(diction['comment']).strip()
|
|
|
|
|
|
"""
|
|
Pour gerer la date de validation, differemment d'une simple mise à jour,
|
|
on recuperer 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']
|
|
|
|
local_retval = coll_inscription.find_one(query_key)
|
|
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"))
|
|
|
|
|
|
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.
|
|
|
|
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']
|
|
|
|
# ici recup du titre
|
|
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
|
|
|
|
# ici recup des infos de la session
|
|
local_query = {'formation_session_id':str(mysession_id)}
|
|
print("### local_query = "+str(local_query))
|
|
|
|
|
|
for local_tmp_session in MYSY_GV.dbname['session_formation'].find(local_query):
|
|
|
|
local_date_du = ""
|
|
if ("date_debut" in local_tmp_session.keys() and local_tmp_session['date_debut']):
|
|
local_date_du = str(local_tmp_session['date_debut'])[0:10]
|
|
email_data['date_du'] = local_date_du
|
|
|
|
|
|
local_date_au = ""
|
|
if ("date_fin" in local_tmp_session.keys() and local_tmp_session['date_fin']):
|
|
local_date_au = str(local_tmp_session['date_fin'])[0:10]
|
|
email_data['date_au'] = local_date_au
|
|
|
|
local_adresse = ""
|
|
if ("adresse" in local_tmp_session.keys() and local_tmp_session['adresse']):
|
|
local_adresse = local_tmp_session['adresse']
|
|
email_data['adresse'] = local_adresse
|
|
|
|
local_cp= ""
|
|
if ("code_postal" in local_tmp_session.keys() and local_tmp_session['code_postal']):
|
|
local_cp = local_tmp_session['code_postal']
|
|
email_data['code_postal'] = local_cp
|
|
|
|
local_ville = ""
|
|
if ("ville" in local_tmp_session.keys() and local_tmp_session['ville']):
|
|
local_ville = local_tmp_session['ville']
|
|
email_data['ville'] = local_ville
|
|
|
|
local_distance = ""
|
|
if ("distantiel" in local_tmp_session.keys() and local_tmp_session['distantiel']):
|
|
local_distance = local_tmp_session['distantiel']
|
|
email_data['distantiel'] = local_distance
|
|
|
|
|
|
local_presence = ""
|
|
if ("presentiel" in local_tmp_session.keys() and local_tmp_session['presentiel']):
|
|
local_presence = local_tmp_session['presentiel']
|
|
email_data['presentiel'] = local_presence
|
|
|
|
local_formateur = ""
|
|
if ("formateur" in local_tmp_session.keys() and local_tmp_session['formateur']):
|
|
local_formateur = local_tmp_session['formateur']
|
|
email_data['formateur'] = local_formateur
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in local_tmp_session.keys() and local_tmp_session['distantiel']):
|
|
distantiel = local_tmp_session['distantiel']
|
|
email_data['distantiel'] = distantiel
|
|
|
|
presentiel = ""
|
|
if ("presentiel" in local_tmp_session.keys() and local_tmp_session['presentiel']):
|
|
presentiel = local_tmp_session['presentiel']
|
|
email_data['presentiel'] = presentiel
|
|
|
|
lms_class_code = ""
|
|
if ("lms_class_code" in local_tmp_session.keys() and local_tmp_session['lms_class_code']):
|
|
lms_class_code = local_tmp_session['lms_class_code']
|
|
|
|
session_ondemande = ""
|
|
if ("session_ondemande" in local_tmp_session.keys() and local_tmp_session['session_ondemande']):
|
|
session_ondemande = local_tmp_session['session_ondemande']
|
|
email_data['session_ondemande'] = session_ondemande
|
|
|
|
|
|
if ( diction['status'] == "1" ):
|
|
# Il s'agit d'envoyer le message de confirmation d'une inscription
|
|
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 ( 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( str(return_message) != " "):
|
|
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 recuperer 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 recuperer 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 recuperer 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 recuperer la liste des stagiaires . Toutes les informations fournies ne sont pas valables"
|
|
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'class_internal_url', 'session_id']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - : La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, "Impossible de recuperer la liste des stagiaires, Toutes les informations necessaires n'ont pas été fournies"
|
|
|
|
# Recuperation du recid du partner
|
|
mydata = {}
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = diction['token']
|
|
|
|
# Verifier la validité du token
|
|
retval = mycommon.check_partner_token_validity("", mytoken)
|
|
if retval is False:
|
|
return "Err_Connexion", " La session de connexion n'est pas valide"
|
|
|
|
|
|
partner_recid = mycommon.get_parnter_recid_from_token(mytoken)
|
|
if (partner_recid is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer la liste des stagiaires, ")
|
|
return False, "Impossible de recuperer la liste des stagiaires, Les informations d'identification sont incorrectes "
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
class_internal_url = diction['class_internal_url']
|
|
|
|
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 = 1
|
|
|
|
print(" #### myquery 01= "+str(myquery))
|
|
|
|
for retval in coll_session.find(myquery):
|
|
user = retval
|
|
user['id'] = str(val_tmp)
|
|
val_tmp = val_tmp + 1
|
|
RetObject.append(mycommon.JSONEncoder().encode(user))
|
|
|
|
|
|
return True, RetObject
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, "Impossible de recuperer 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 recuperer 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_session = MYSY_GV.dbname['inscription'].find({'session_id':str(diction['session_id']),
|
|
'email':str(diction['email'])})
|
|
local_nom = ""
|
|
if ("nom" in local_session[0].keys()):
|
|
if local_session[0]['nom']:
|
|
local_nom = local_session[0]['nom']
|
|
data_mail['nom'] = local_nom
|
|
|
|
local_prenom = ""
|
|
if ("prenom" in local_session[0].keys()):
|
|
if local_session[0]['prenom']:
|
|
local_prenom = local_session[0]['prenom']
|
|
data_mail['prenom'] = local_prenom
|
|
|
|
data_mail['email'] = local_session[0]['email']
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_session[0].keys()):
|
|
if local_session[0]['date_du']:
|
|
date_du = local_session[0]['date_du']
|
|
data_mail['date_du'] = str(date_du)[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_session[0].keys()):
|
|
if local_session[0]['date_au']:
|
|
date_au = local_session[0]['date_au']
|
|
data_mail['date_au'] = str(date_au)[0:10]
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_session[0].keys()):
|
|
if local_session[0]['adresse']:
|
|
adresse = local_session[0]['adresse']
|
|
data_mail['adresse'] = adresse
|
|
|
|
session_ondemande = ""
|
|
if ("session_ondemande" in local_session[0].keys()):
|
|
if local_session[0]['session_ondemande']:
|
|
session_ondemande = local_session[0]['session_ondemande']
|
|
data_mail['session_ondemande'] = session_ondemande
|
|
|
|
|
|
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', '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 pre-inscription "
|
|
|
|
|
|
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']
|
|
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)})
|
|
data_mail['partner_mail'] = local_partner['email']
|
|
|
|
|
|
|
|
# 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'])})
|
|
|
|
|
|
data_mail['nom'] = local_session[0]['nom']
|
|
data_mail['prenom'] = local_session[0]['prenom']
|
|
data_mail['email'] = local_session[0]['email']
|
|
|
|
|
|
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']
|
|
|
|
|
|
|
|
|
|
#3 - Recuperations des info de la session (a distance, formateur, etc)
|
|
local_info_session = MYSY_GV.dbname['session_formation'].find({'formation_session_id': 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 "
|
|
|
|
if ("code_postal" in local_info_session[0].keys()):
|
|
if local_info_session[0]['code_postal']:
|
|
data_mail['code_postal'] = local_info_session[0]['code_postal']
|
|
|
|
if ("date_debut" in local_info_session[0].keys()):
|
|
if local_info_session[0]['date_debut']:
|
|
data_mail['date_du'] = str(local_info_session[0]['date_debut'])[0:10]
|
|
|
|
if ("date_fin" in local_info_session[0].keys()):
|
|
if local_info_session[0]['date_fin']:
|
|
data_mail['date_au'] = str(local_info_session[0]['date_fin'])[0:10]
|
|
|
|
|
|
if ("formateur" in local_info_session[0].keys()):
|
|
if local_info_session[0]['formateur']:
|
|
data_mail['formateur'] = local_info_session[0]['formateur']
|
|
|
|
if ("distantiel" in local_info_session[0].keys()):
|
|
if local_info_session[0]['distantiel']:
|
|
data_mail['distantiel'] = local_info_session[0]['distantiel']
|
|
|
|
if ("presentiel" in local_info_session[0].keys()):
|
|
if local_info_session[0]['presentiel']:
|
|
data_mail['presentiel'] = local_info_session[0]['presentiel']
|
|
|
|
if ("ville" in local_info_session[0].keys()):
|
|
if local_info_session[0]['ville']:
|
|
data_mail['ville'] = local_info_session[0]['ville']
|
|
|
|
if ("adresse" in local_info_session[0].keys()):
|
|
if local_info_session[0]['adresse']:
|
|
data_mail['adresse'] = local_info_session[0]['adresse']
|
|
|
|
if ("session_ondemande" in local_info_session[0].keys()):
|
|
if local_info_session[0]['session_ondemande']:
|
|
data_mail['session_ondemande'] = local_info_session[0]['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 recuperer 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({'formation_session_id':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 = 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 recuperer 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({'formation_session_id':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"
|
|
|
|
'''
|
|
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']
|
|
|
|
# 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 formation (class_internal_url)
|
|
tmp_count = MYSY_GV.dbname['myclass'].count_documents({'internal_url': str(class_internal_url), 'valide': '1', 'locked':'0'})
|
|
|
|
# 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 "
|
|
|
|
|
|
|
|
if(len(str(session_id).strip()) <= 0 ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " La session de formation est vide : Impossible d'importer la liste des participants ")
|
|
return False, " La session de formation est incorrecte. Impossible d'importer la liste des participants"
|
|
|
|
|
|
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):
|
|
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
|
|
|
|
df = pd.read_csv(saved_file, encoding='utf8', on_bad_lines='skip', sep=';', encoding_errors='ignore')
|
|
|
|
# Dictionnaire des champs utilisables
|
|
'''
|
|
# Verification que les noms des colonne sont bien corrects"
|
|
'''
|
|
field_list = ['prenom', 'nom', 'employeur', 'telephone', 'email', 'modefinancement',
|
|
'opco', 'status', 'prix']
|
|
|
|
|
|
# Controle du nombre de lignes dans le fichier.
|
|
total_rows = len(df)
|
|
if( total_rows > MYSY_GV.MAX_PARTICIPANT_BY_CSV ):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " Le fichier comporte plus de "+str(MYSY_GV.MAX_PARTICIPANT_BY_CSV)+" lignes.")
|
|
return False, " Le fichier comporte plus de "+str(MYSY_GV.MAX_PARTICIPANT_BY_CSV)+" lignes."
|
|
|
|
|
|
#print(df.columns)
|
|
for val in df.columns:
|
|
if str(val).lower() not in field_list:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3])+" : entete du fichier csv. '" + val + "' n'est pas acceptée")
|
|
return False, " Entete du fichier csv. '" + val + "' n'est pas acceptée"
|
|
|
|
# Verification des champs obligatoires dans le fichier
|
|
field_list_obligatoire_file = ['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])
|
|
mydata['session_id'] = str(session_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
|
|
|
|
|
|
opco = ""
|
|
if ("opco" in df.keys()):
|
|
if (str(df['opco'].values[n])):
|
|
opco = str(df['opco'].values[n])
|
|
mydata['opco'] = opco
|
|
|
|
|
|
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 champs 'status' de ligne " + str(n) + " est incorrecte. Valeurs acceptées : 0,1,2")
|
|
return False, " Le champs 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"))
|
|
|
|
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 champs 'prix' de ligne " + str( n) + " est incorrecte.")
|
|
return False, " Le champs prix de 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 "
|
|
|
|
|
|
"""
|
|
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']
|
|
|
|
# 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"
|
|
|
|
RetObject = []
|
|
# Recuperation des infos de la formation
|
|
local_Insc_retval = MYSY_GV.dbname['inscription'].find_one({'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email']),
|
|
'class_internal_url':str(diction['internal_url'])})
|
|
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'])})
|
|
|
|
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']
|
|
|
|
|
|
|
|
|
|
# Recuperation du formation depuis la collection "session_formation"
|
|
tmp_val = MYSY_GV.dbname['session_formation'].find_one({'formation_session_id':str(local_Insc_retval['session_id']), 'valide':'1'})
|
|
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)
|
|
|
|
|
|
#print(" ### tab_presences =",tab_presences)
|
|
|
|
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_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']),
|
|
"eval_date": {"$exists": True}})
|
|
|
|
if (tmp_count > 0):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Vous avez deja evalué cette formation")
|
|
return False, " Vous avez deja evalué cette formation"
|
|
|
|
|
|
RetObject = []
|
|
# Recuperation des infos de la formation
|
|
local_Insc_retval = MYSY_GV.dbname['inscription'].find_one({'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email']),
|
|
'class_internal_url': str(diction['class_internal_url'])})
|
|
|
|
my_retrun_dict = {}
|
|
|
|
print(' ##### local_Insc_retval = ', local_Insc_retval)
|
|
|
|
my_retrun_dict['token_eval'] = local_Insc_retval['_id']
|
|
my_retrun_dict['session_id'] = local_Insc_retval['session_id']
|
|
my_retrun_dict['date_du'] = str(local_Insc_retval['date_du'])[1:10]
|
|
my_retrun_dict['date_au'] = str(local_Insc_retval['date_au'])[0:10]
|
|
|
|
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
|
|
|
|
print(" ###### LAAA 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({'formation_session_id': str(diction['session_id']),
|
|
'valide': '1'})
|
|
|
|
|
|
if( local_session_info is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de recuperer les données de la session de formation")
|
|
return False, " Impossible de recuperer les données de la session de formation"
|
|
|
|
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']:
|
|
my_retrun_dict['session_ondemande'] = local_session_info['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({'formation_session_id': str(diction['session_id']),
|
|
'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_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 recuperer les données de l'inscrit")
|
|
return False, " Impossible de recuperer 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 evalué cette formation")
|
|
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 recuperer les données du partenaire")
|
|
return False, " Impossible de recuperer 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(
|
|
{'formation_session_id': str(diction['session_id']),
|
|
'valide': "1", 'class_internal_url':str(diction['internal_url'])})
|
|
|
|
if ("attestation_certif" not in session_formation.keys()):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " impossible de trouver le modele d'attestation")
|
|
return False, " impossible de trouver le modele d'attestation"
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in session_formation.keys()):
|
|
distantiel = session_formation['distantiel']
|
|
my_retrun_dict['distantiel'] = distantiel
|
|
|
|
distantiel = ""
|
|
if ("distantiel" in session_formation.keys()):
|
|
distantiel = session_formation['formateur']
|
|
my_retrun_dict['distantiel'] = distantiel
|
|
|
|
formateur = ""
|
|
if ("formateur" in session_formation.keys()):
|
|
formateur = session_formation['formateur']
|
|
my_retrun_dict['formateur'] = formateur
|
|
|
|
contenu_ftion = ""
|
|
if ("contenu_ftion" in session_formation.keys()):
|
|
contenu_ftion = str(session_formation['contenu_ftion']).replace('<p>', '').replace('</p>', '').replace("\r\n", '<br/>')
|
|
my_retrun_dict['contenu_ftion'] = contenu_ftion
|
|
|
|
|
|
# Recuperation des données de l'attestation
|
|
attestation_certificat = MYSY_GV.dbname['attestation_certificat'].find_one(
|
|
{'nom': str(session_formation['attestation_certif']),
|
|
'valide': "1"})
|
|
|
|
if( attestation_certificat is None ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " impossible de trouver le modele d'attestation (2)")
|
|
return False, " impossible de trouver le modele d'attestation (2)"
|
|
|
|
if ("template_name" not in attestation_certificat.keys()):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " impossible de trouver le modele d'attestation (3)")
|
|
return False, " impossible de trouver le modele d'attestation (3)"
|
|
|
|
|
|
|
|
my_retrun_dict['attestation_tmpl'] = attestation_certificat['template_name']
|
|
|
|
# Recuperation des info de l'inscrit
|
|
local_Insc_retval = MYSY_GV.dbname['inscription'].find_one({'session_id': str(diction['session_id']),
|
|
'email': str(diction['attendee_email'])})
|
|
|
|
if (local_Insc_retval is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de recuperer les données de l'inscrit")
|
|
return False, " Impossible de recuperer les données de l'inscrit"
|
|
|
|
my_retrun_dict['date_du'] = str(local_Insc_retval['date_du'])[0:10]
|
|
my_retrun_dict['date_au'] = str(local_Insc_retval['date_au'])[0:10]
|
|
|
|
ville = ""
|
|
if ("ville" in local_Insc_retval.keys()):
|
|
ville = local_Insc_retval['ville']
|
|
my_retrun_dict['ville'] = ville
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in local_Insc_retval.keys()):
|
|
code_postal = local_Insc_retval['code_postal']
|
|
my_retrun_dict['code_postal'] = code_postal
|
|
|
|
class_internal_url = ""
|
|
if ("class_internal_url" in local_Insc_retval.keys()):
|
|
class_internal_url = local_Insc_retval['class_internal_url']
|
|
my_retrun_dict['internal_url'] = class_internal_url
|
|
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_Insc_retval.keys()):
|
|
adresse = local_Insc_retval['adresse']
|
|
my_retrun_dict['adresse'] = adresse
|
|
|
|
nom = ""
|
|
if ("nom" in local_Insc_retval.keys()):
|
|
nom = local_Insc_retval['nom']
|
|
my_retrun_dict['nom'] = nom
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_Insc_retval.keys()):
|
|
prenom = local_Insc_retval['prenom']
|
|
my_retrun_dict['prenom'] = prenom
|
|
|
|
employeur = ""
|
|
if ("employeur" in local_Insc_retval.keys()):
|
|
employeur = local_Insc_retval['employeur']
|
|
my_retrun_dict['employeur'] = employeur
|
|
|
|
telephone = ""
|
|
if ("telephone" in local_Insc_retval.keys()):
|
|
telephone = local_Insc_retval['telephone']
|
|
my_retrun_dict['telephone'] = telephone
|
|
|
|
email = ""
|
|
if ("email" in local_Insc_retval.keys()):
|
|
email = local_Insc_retval['email']
|
|
my_retrun_dict['email'] = email
|
|
|
|
|
|
|
|
# Recuperation des infotrmations de la formation
|
|
#print(" ## str(local_Insc_retval['class_internal_url']) = ", str(local_Insc_retval['class_internal_url']))
|
|
local_formation = MYSY_GV.dbname['myclass'].find_one(
|
|
{'internal_url': str(local_Insc_retval['class_internal_url'])})
|
|
|
|
if( local_formation is None ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " Impossible de recuperer les données de la formation ")
|
|
return False, " Impossible de recuperer les données de la formation"
|
|
|
|
title = ""
|
|
if ("title" in local_formation.keys()):
|
|
title = local_formation['title']
|
|
my_retrun_dict['class_title'] = title
|
|
|
|
logo_url = ""
|
|
if ("img_url" in local_formation.keys()):
|
|
logo_url = local_formation['img_url']
|
|
my_retrun_dict['logo_url'] = logo_url
|
|
|
|
|
|
templateLoader = jinja2.FileSystemLoader(searchpath="./")
|
|
templateEnv = jinja2.Environment(loader=templateLoader)
|
|
TEMPLATE_FILE = "Template/"+str(my_retrun_dict['attestation_tmpl'])+".html"
|
|
template = templateEnv.get_template(TEMPLATE_FILE)
|
|
# This data can come from database query
|
|
body = {
|
|
"data": my_retrun_dict,
|
|
|
|
}
|
|
|
|
print(" ### body = " + str(body))
|
|
|
|
sourceHtml = template.render(json_data=body["data"])
|
|
mycode = str(datetime.now().timestamp()).replace(".", '').replace(',', '')
|
|
orig_file_name = "Attestation_" + str(mycode)[:-3] + "pdf"
|
|
|
|
outputFilename = str(MYSY_GV.TEMPORARY_DIRECTORY) + str(orig_file_name)
|
|
|
|
# open output file for writing (truncated binary)
|
|
resultFile = open(outputFilename, "w+b")
|
|
|
|
# convert HTML to PDF
|
|
pisaStatus = pisa.CreatePDF(
|
|
src=sourceHtml, # the HTML to convert
|
|
dest=resultFile) # file handle to receive result
|
|
|
|
# close output file
|
|
resultFile.close()
|
|
|
|
# print(" ### outputFilename = "+str(outputFilename))
|
|
if os.path.exists(outputFilename):
|
|
# print(" ### ok os.path.exists(outputFilename) "+str(outputFilename))
|
|
return True, send_file(outputFilename, as_attachment=True)
|
|
|
|
# return True on success and False on errors
|
|
print(pisaStatus.err, type(pisaStatus.err))
|
|
|
|
return True, " le fichier generé "
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible d'envoyer l'attestation"
|
|
|
|
|
|
"""
|
|
Cette fonction recuperer la liste des evaluations d'une session de formation
|
|
"""
|
|
def GetListEvaluation_Session(diction):
|
|
try:
|
|
field_list_obligatoire = ['session_id', 'token']
|
|
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + " La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Les informations fournies sont incorrectes"
|
|
|
|
my_token = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
my_token = diction['token']
|
|
|
|
# Verifier la validité du token
|
|
retval = mycommon.check_partner_token_validity("", my_token)
|
|
if retval is False:
|
|
return "Err_Connexion", " La session de connexion n'est pas valide"
|
|
|
|
|
|
# Recuperation du recid du partenaire
|
|
partner_recid = mycommon.get_parnter_recid_from_token(str(my_token))
|
|
if partner_recid is False:
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer la liste des evaluations")
|
|
return False, " Les informations fournies sont incorrectes"
|
|
|
|
RetObject = []
|
|
val_tmp = 1
|
|
|
|
|
|
# Recuperation des infos de la formation
|
|
for local_Insc_retval in MYSY_GV.dbname['inscription'].find({'session_id': str(diction['session_id'])}):
|
|
user = {}
|
|
user['id'] = str(val_tmp)
|
|
val_tmp = val_tmp + 1
|
|
user['session_id'] = local_Insc_retval['session_id']
|
|
user['email'] = local_Insc_retval['email']
|
|
user['nom'] = local_Insc_retval['nom']
|
|
user['prenom'] = local_Insc_retval['prenom']
|
|
|
|
|
|
if ("eval_date" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['eval_date']:
|
|
user['eval_date'] = local_Insc_retval['eval_date']
|
|
|
|
if ("eval_eval" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['eval_eval']:
|
|
user['eval_eval'] = local_Insc_retval['eval_eval']
|
|
else:
|
|
user['eval_eval'] = "---"
|
|
|
|
if ("eval_note" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['eval_note']:
|
|
user['eval_note'] = local_Insc_retval['eval_note']
|
|
else:
|
|
user['eval_note'] = "---"
|
|
|
|
|
|
if ("eval_pedagogie" in local_Insc_retval.keys()):
|
|
if local_Insc_retval['eval_pedagogie']:
|
|
user['eval_pedagogie'] = local_Insc_retval['eval_pedagogie']
|
|
|
|
|
|
RetObject.append(mycommon.JSONEncoder().encode(user))
|
|
|
|
|
|
return True, RetObject
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de recuperer la liste des evaluations"
|
|
|
|
|
|
"""
|
|
Cette fonction permet d'annuler l'inscription à une formation.
|
|
# status -1 ==> Inscription annulée
|
|
"""
|
|
def CancelAttendeeInscription(diction):
|
|
try:
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'email', 'class_internal_url', 'session_id']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - : La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Les informations fournies ne sont pas correctes"
|
|
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = diction['token']
|
|
|
|
# Verifier la validité du token
|
|
retval = mycommon.check_partner_token_validity("", mytoken)
|
|
if retval is False:
|
|
return "Err_Connexion", " La session de connexion n'est pas valide"
|
|
|
|
partner_recid = mycommon.get_parnter_recid_from_token(mytoken)
|
|
if (partner_recid is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer le recid du partenaire")
|
|
return False, "Impossible de recuperer le recid du partenaire"
|
|
|
|
data_mail = {}
|
|
# 1 - Recuperation des données de la formation
|
|
local_class = MYSY_GV.dbname['myclass'].find({'internal_url': str(diction['class_internal_url'])})
|
|
data_mail['title'] = local_class[0]['title']
|
|
class_title = local_class[0]['title']
|
|
|
|
# 2 - Recuperation des données de l'inscription
|
|
local_inscription = MYSY_GV.dbname['inscription'].find({'session_id': str(diction['session_id']),
|
|
'email': str(diction['email'])})
|
|
lms_class_code = ""
|
|
if ("lms_class_code" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_class_code']:
|
|
lms_class_code = local_inscription[0]['lms_class_code']
|
|
|
|
lms_user_id = ""
|
|
if ("lms_user_id" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_user_id']:
|
|
lms_user_id = local_inscription[0]['lms_user_id']
|
|
|
|
nom = ""
|
|
if ("nom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['nom']:
|
|
nom = local_inscription[0]['nom']
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['prenom']:
|
|
prenom = local_inscription[0]['prenom']
|
|
|
|
email = ""
|
|
if ("email" in local_inscription[0].keys()):
|
|
if local_inscription[0]['email']:
|
|
email = local_inscription[0]['email']
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_du']:
|
|
date_du = str(local_inscription[0]['date_du'])[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_au']:
|
|
date_au = str(local_inscription[0]['date_au'])[0:10]
|
|
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'formation_session_id': str(diction['session_id']), 'class_internal_url': str(diction['class_internal_url'])})
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer les données de la session ")
|
|
return False, " Impossible de recuperer les données de la session "
|
|
|
|
# Annulation de l'inscription
|
|
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
|
|
ret_val2 = MYSY_GV.dbname['inscription'].find_one_and_update(
|
|
{'session_id': str(diction['session_id']), 'email': str(diction['email'])},
|
|
{"$set": {'status':'-1', 'inscription_refuse_date':now, 'date_update':now}},
|
|
return_document=ReturnDocument.AFTER,
|
|
upsert=False,
|
|
)
|
|
|
|
if( ret_val2 is None ):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible d'annuler l'inscription ")
|
|
return False, " Impossible d'annuler l'inscription "
|
|
|
|
"""
|
|
Verification s'il y a une inscription LMS, au quel cas, on l'annule aussi
|
|
"""
|
|
|
|
return_message = ""
|
|
|
|
if( lms_user_id.strip() != ""):
|
|
# Il a une inscription à une formation dans le LMS, il faut l'annuler
|
|
new_diction = {}
|
|
new_diction['token'] = str(diction['token'])
|
|
new_diction['user_lms_id'] = str(lms_user_id)
|
|
new_diction['course_code'] = str(lms_class_code)
|
|
|
|
local_status, local_message = mys_lms.Remove_User_From_LMS_Class(new_diction)
|
|
if (local_status is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - WARNING : Impossible de supprimer l'inscription dans le LMS pour "+str( diction['email']) )
|
|
return_message = "Impossible de supprimer l'inscription dans le LMS pour : "+str( diction['email'])
|
|
|
|
email_data = {}
|
|
email_data['nom'] = nom
|
|
email_data['prenom'] = prenom
|
|
email_data['email'] = email
|
|
email_data['date_du'] = date_du
|
|
email_data['date_au'] = date_au
|
|
email_data['title'] = class_title
|
|
|
|
local_status, local_message = email_session.incription_training_cancelled_mail(email_data)
|
|
if( local_status is False ):
|
|
mycommon.myprint(str(
|
|
inspect.stack()[0][3]) + " - WARNING : Impossible d'envoyer le mail de notification pour " + str(
|
|
diction['email']))
|
|
return_message = return_message + str(" Impossible d'envoyer le mail de notification pour : " + str(diction['email']))
|
|
|
|
if( return_message.strip() != ""):
|
|
return True, return_message
|
|
|
|
return True, "L'inscription a été correctement supprimée"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de recuperer la liste des evaluations"
|
|
|
|
|
|
"""
|
|
Cette fonction envoie l'email de connexion à la plateformation LMS
|
|
au participant
|
|
Cet email met en copie le responsable de la formation. ceci pour pouvoir renvoyer le mail au besoin
|
|
"""
|
|
def Send_LMS_Credentials_to_particpants(diction):
|
|
try:
|
|
"""
|
|
Verification de la liste des champs obligatoires
|
|
"""
|
|
field_list_obligatoire = ['token', 'email', 'class_internal_url', 'session_id']
|
|
for val in field_list_obligatoire:
|
|
if val not in diction:
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " - : La valeur '" + val + "' n'est pas presente dans liste ")
|
|
return False, " Les informations fournies ne sont pas correctes"
|
|
|
|
mytoken = ""
|
|
if ("token" in diction.keys()):
|
|
if diction['token']:
|
|
mytoken = diction['token']
|
|
|
|
partner_recid = mycommon.get_parnter_recid_from_token(mytoken)
|
|
if (partner_recid is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer le recid du partenaire")
|
|
return False, "Impossible de recuperer le recid du partenaire"
|
|
|
|
# 0 -Recuperation des données du partenaire
|
|
local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
|
|
if (local_status is False):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de recuperer les données du partenaire")
|
|
return False, " - impossible de recuperer les données du partenaire"
|
|
|
|
|
|
# Par defaut, lms_virtualhost_url = l'url racine.
|
|
lms_virtualhost_url = MYSY_GV.MYSY_LMS_URL
|
|
if ("lms_virtualhost_url" in my_partner.keys()):
|
|
if my_partner['lms_virtualhost_url']:
|
|
lms_virtualhost_url = my_partner['lms_virtualhost_url']
|
|
|
|
|
|
data_mail = {}
|
|
# 1 - Recuperation des données de la formation
|
|
local_class = MYSY_GV.dbname['myclass'].find({'internal_url': str(diction['class_internal_url'])})
|
|
data_mail['title'] = local_class[0]['title']
|
|
class_title = local_class[0]['title']
|
|
|
|
# 2 - Recuperation des données de l'inscription
|
|
local_inscription = MYSY_GV.dbname['inscription'].find({'session_id': str(diction['session_id']),
|
|
'email': str(diction['email'])})
|
|
lms_class_code = ""
|
|
if ("lms_class_code" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_class_code']:
|
|
lms_class_code = local_inscription[0]['lms_class_code']
|
|
|
|
lms_user_id = ""
|
|
if ("lms_user_id" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_user_id']:
|
|
lms_user_id = local_inscription[0]['lms_user_id']
|
|
|
|
lms_pwd = ""
|
|
if ("lms_pwd" in local_inscription[0].keys()):
|
|
if local_inscription[0]['lms_pwd']:
|
|
lms_pwd = local_inscription[0]['lms_pwd']
|
|
|
|
nom = ""
|
|
if ("nom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['nom']:
|
|
nom = local_inscription[0]['nom']
|
|
|
|
prenom = ""
|
|
if ("prenom" in local_inscription[0].keys()):
|
|
if local_inscription[0]['prenom']:
|
|
prenom = local_inscription[0]['prenom']
|
|
|
|
email = ""
|
|
if ("email" in local_inscription[0].keys()):
|
|
if local_inscription[0]['email']:
|
|
email = local_inscription[0]['email']
|
|
|
|
date_du = ""
|
|
if ("date_du" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_du']:
|
|
date_du = str(local_inscription[0]['date_du'])[0:10]
|
|
|
|
date_au = ""
|
|
if ("date_au" in local_inscription[0].keys()):
|
|
if local_inscription[0]['date_au']:
|
|
date_au = str(local_inscription[0]['date_au'])[0:10]
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one(
|
|
{'formation_session_id': str(diction['session_id']),
|
|
'class_internal_url': str(diction['class_internal_url'])})
|
|
|
|
if (local_session is None):
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de recuperer les données de la session ")
|
|
return False, " Impossible de recuperer les données de la session "
|
|
|
|
|
|
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
|
|
|
|
return_message = ""
|
|
email_data = {}
|
|
email_data['nom'] = nom
|
|
email_data['prenom'] = prenom
|
|
email_data['email'] = email
|
|
email_data['date_du'] = date_du
|
|
email_data['date_au'] = date_au
|
|
email_data['title'] = class_title
|
|
|
|
email_data['login'] = email
|
|
email_data['pwd'] = lms_pwd
|
|
email_data['lms_url'] = str(lms_virtualhost_url)
|
|
email_data['course_owner_email'] = my_partner['email']
|
|
email_data['partner_recid'] = my_partner['recid']
|
|
|
|
#split_mail_tab = str(email).split('@')
|
|
#email_data['login'] = split_mail_tab[0]
|
|
|
|
|
|
local_status, local_message = email_session.LMS_Credential_Sending_mail(email_data)
|
|
if (local_status is False):
|
|
mycommon.myprint(str(
|
|
inspect.stack()[0][3]) + " - WARNING : Impossible d'envoyer le mail de notification pour " + str(
|
|
diction['email']))
|
|
return_message = return_message + str(
|
|
" Impossible d'envoyer le mail de notification pour : " + str(diction['email']))
|
|
|
|
if (return_message.strip() != ""):
|
|
return True, return_message
|
|
|
|
|
|
return True, " Les informations de connexion ont été correctement envoyées"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible d'envoyer les informations de connexion à la plateforme LMS"
|