Elyos_FI_Back_Office/Inscription_mgt.py

465 lines
18 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
"""
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']
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']
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(" #### pour la session_id "+str(session_id)+" on est a "+str(session_date_du)+" - "+str(session_adresse))
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 ("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")
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
"""
def UpdateStagiairetoClass(diction):
try:
field_list = ['token', 'email', 'nom', 'prenom', 'telephone', 'modefinancement', 'opco',
'status', 'class_internal_url', 'session_id', 'price']
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']
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']
if ("status" in diction.keys()):
if diction['status']:
mydata['status'] = diction['status']
print(" ### query_key = "+str(query_key))
print(' ### mydata = '+str(mydata))
coll_inscription = MYSY_GV.dbname['inscription']
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.
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
# 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
local_status, local_message = email_session.incription_training_confirmation_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 soihaité 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"
return True, "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"