775 lines
31 KiB
Python
775 lines
31 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
|
|
|
|
"""
|
|
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']
|
|
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', 'opco',
|
|
'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, Toutes les informations necessaires n'ont pas été fournies"
|
|
|
|
mydata = {}
|
|
|
|
session_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
mydata['session_id'] = diction['session_id']
|
|
session_id = diction['session_id']
|
|
|
|
"""
|
|
Recuperation des info de la session de formation
|
|
"""
|
|
|
|
for tmp_val in MYSY_GV.dbname['myclass'].find({"datelieu.session_id":str(session_id)}):
|
|
|
|
tmp_date_lieu = tmp_val['datelieu']
|
|
print(" #### tmp_date_lieu = "+str(tmp_date_lieu))
|
|
|
|
for val in tmp_date_lieu:
|
|
if( val['session_id'] == str(session_id) ):
|
|
mydata['date_du'] = val['date_du']
|
|
mydata['date_au'] = val['date_au']
|
|
mydata['ville'] = val['ville']
|
|
mydata['code_postal'] = val['code_postal']
|
|
mydata['adresse'] = val['adresse']
|
|
|
|
print(" #### mydata = "+str(mydata))
|
|
|
|
if ("nom" in diction.keys()):
|
|
if diction['nom']:
|
|
mydata['nom'] = diction['nom']
|
|
|
|
if ("prenom" in diction.keys()):
|
|
if diction['prenom']:
|
|
mydata['prenom'] = diction['prenom']
|
|
|
|
if ("employeur" in diction.keys()):
|
|
if diction['employeur']:
|
|
mydata['employeur'] = diction['employeur']
|
|
|
|
if ("telephone" in diction.keys()):
|
|
if diction['telephone']:
|
|
mydata['telephone'] = diction['telephone']
|
|
|
|
if ("email" in diction.keys()):
|
|
if diction['email']:
|
|
mydata['email'] = diction['email']
|
|
|
|
if ("modefinancement" in diction.keys()):
|
|
if diction['modefinancement']:
|
|
mydata['modefinancement'] = diction['modefinancement']
|
|
|
|
if ("opco" in diction.keys()):
|
|
if diction['opco']:
|
|
mydata['opco'] = diction['opco']
|
|
|
|
|
|
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
mydata['class_internal_url'] = diction['class_internal_url']
|
|
|
|
mydata['date_update'] = str(datetime.now())
|
|
mydata['status'] = "0" # 0 ==> Preinscription
|
|
mydata['price'] = "0"
|
|
|
|
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 inscrit à la session du "
|
|
" "+str( mydata['session_id'])+ " ")
|
|
|
|
return False, "Impossible de créer le stagiaire. l'adresse email "+str(mydata['email'])\
|
|
+" est deja inscrit à la session du "+str( mydata['session_id'])+ " "
|
|
|
|
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 sessio " + 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
|
|
|
|
"""
|
|
def UpdateStagiairetoClass(diction):
|
|
try:
|
|
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 = diction['token']
|
|
#query_key['token'] = diction['token']
|
|
|
|
myemail = ""
|
|
if ("email" in diction.keys()):
|
|
if diction['email']:
|
|
myemail = diction['email']
|
|
query_key['email'] = diction['email']
|
|
|
|
myinternal_url = ""
|
|
if ("class_internal_url" in diction.keys()):
|
|
if diction['class_internal_url']:
|
|
myinternal_url = diction['class_internal_url']
|
|
query_key['class_internal_url'] = diction['class_internal_url']
|
|
|
|
mysession_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
mysession_id = diction['session_id']
|
|
query_key['session_id'] = diction['session_id']
|
|
|
|
|
|
|
|
|
|
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'] = diction['nom']
|
|
user_nom = diction['nom']
|
|
|
|
if ("price" in diction.keys()):
|
|
if diction['price']:
|
|
mydata['price'] = diction['price']
|
|
|
|
if ("employeur" in diction.keys()):
|
|
if diction['employeur']:
|
|
mydata['employeur'] = diction['employeur']
|
|
|
|
user_prenom = ""
|
|
if ("prenom" in diction.keys()):
|
|
if diction['prenom']:
|
|
mydata['prenom'] = diction['prenom']
|
|
user_prenom = diction['prenom']
|
|
|
|
if ("telephone" in diction.keys()):
|
|
if diction['telephone']:
|
|
mydata['telephone'] = diction['telephone']
|
|
|
|
if ("modefinancement" in diction.keys()):
|
|
if diction['modefinancement']:
|
|
mydata['modefinancement'] = diction['modefinancement']
|
|
|
|
if ("opco" in diction.keys()):
|
|
if diction['opco']:
|
|
mydata['opco'] = diction['opco']
|
|
|
|
if ("price" in diction.keys()):
|
|
if diction['price']:
|
|
mydata['price'] = diction['price']
|
|
|
|
new_status = ""
|
|
if ("status" in diction.keys()):
|
|
if diction['status']:
|
|
mydata['status'] = diction['status']
|
|
new_status = diction['status']
|
|
|
|
|
|
if ("comment" in diction.keys()):
|
|
if diction['comment']:
|
|
mydata['comment'] = diction['comment']
|
|
|
|
|
|
"""
|
|
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']
|
|
if( new_status != old_status ):
|
|
# Il y a eu un changement de status
|
|
if( new_status == "1"):
|
|
mydata['inscription_validation_date'] = str(datetime.now())
|
|
|
|
if (new_status == "-1"):
|
|
mydata['inscription_refuse_date'] = str(datetime.now())
|
|
|
|
|
|
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 = local_tmp_session['date_debut']
|
|
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 = local_tmp_session['date_fin']
|
|
email_data['date_au'] = local_date_au
|
|
|
|
adresse = ""
|
|
if ("adresse" in local_tmp_session.keys() and local_tmp_session['adresse']):
|
|
local_adresse = local_tmp_session['adresse']
|
|
email_data['adresse'] = local_adresse
|
|
|
|
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)
|
|
|
|
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")
|
|
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']
|
|
|
|
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 = "+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']
|
|
|
|
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'])})
|
|
|
|
|
|
data_mail['nom'] = local_session[0]['nom']
|
|
data_mail['prenom'] = local_session[0]['prenom']
|
|
data_mail['email'] = local_session[0]['email']
|
|
data_mail['date_du'] = local_session[0]['date_du']
|
|
data_mail['date_au'] = local_session[0]['date_au']
|
|
data_mail['adresse'] = local_session[0]['adresse']
|
|
|
|
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']
|
|
data_mail['date_du'] = local_session[0]['date_du']
|
|
data_mail['date_au'] = local_session[0]['date_au']
|
|
data_mail['adresse'] = local_session[0]['adresse']
|
|
data_mail['employeur'] = local_session[0]['employeur']
|
|
data_mail['telephone'] = local_session[0]['telephone']
|
|
|
|
|
|
|
|
# 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']
|
|
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 recuperer la liste des stagiaires, Les informations d'identification sont incorrectes "
|
|
|
|
|
|
session_id = ""
|
|
if ("session_id" in diction.keys()):
|
|
if diction['session_id']:
|
|
session_id = diction['session_id']
|
|
|
|
|
|
# Recuperation des données de la session
|
|
local_session = MYSY_GV.dbname['session_formation'].find_one({'formation_session_id':session_id})
|
|
|
|
|
|
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 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(local_session['class_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
|
|
|
|
|
|
RetObject = []
|
|
|
|
for retval in coll_session.find(myquery, { 'session_id':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_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"))
|
|
|
|
adresse = ""
|
|
if ("adresse" in retval.keys()):
|
|
if (retval['adresse']):
|
|
adresse = retval['adresse']
|
|
local_data['adresse'] = adresse
|
|
|
|
code_postal = ""
|
|
if ("code_postal" in retval.keys()):
|
|
if (retval['code_postal']):
|
|
code_postal = retval['code_postal']
|
|
local_data['code_postal'] = code_postal
|
|
|
|
ville = ""
|
|
if ("ville" in retval.keys()):
|
|
if (retval['ville']):
|
|
ville = retval['ville']
|
|
local_data['ville'] = ville
|
|
|
|
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'] = retval['inscription_validation_date']
|
|
|
|
if ("inscription_refuse_date" in retval.keys()):
|
|
if (retval['inscription_refuse_date']):
|
|
local_data['inscription_refuse_date'] = retval['inscription_refuse_date']
|
|
|
|
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" |