Elyos_FI_Back_Office/session_admission_fi.py

2218 lines
95 KiB
Python

"""
Ce fichier permet de gerer les admissions à une formation (promotion)
dans le cadre d'une formation initiale.
Le sessions d'admission sont géré dans une collection appelée admission_session
"""
import ast
from zipfile import ZipFile
import bson
import pymongo
import xlsxwriter
from dateutil.relativedelta import relativedelta
from pymongo import MongoClient
import json
from bson import ObjectId
import re
from datetime import datetime, date
import partner_client
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
import ela_index_bdd_classes as eibdd
import email_mgt as email
import jinja2
from flask import send_file
from xhtml2pdf import pisa
from email.message import EmailMessage
from email.mime.text import MIMEText
from email import encoders
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders
import attached_file_mgt
"""
Creation d'une session d'admission
"""
def Add_Admission_Session(diction):
try:
diction = mycommon.strip_dictionary(diction)
"""
Verification des input acceptés
"""
field_list = ['token', 'date_debut', 'date_fin', 'nb_participant', 'adresse',
'code_postal', 'ville', 'code_session',
'tab_class_id', 'session_status', 'date_debut_inscription',
'date_fin_inscription', "prix_session",'session_ondemande', 'source', 'session_etape', 'pays', 'formateur_id',
'titre', 'location_type', 'site_formation_id', 'mode_animation', 'archive',
'entre_scolaire',
'memo', 'comment', 'class_session_id', 'process_inscription_id']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(
inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
return False, " Les informations fournies sont incorrectes"
"""
Verification des champs obligatoires
"""
field_list_obligatoire = ['token', 'code_session', ]
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 la liste des arguments ")
return False, " Les informations fournies sont incorrectes"
"""
Verification de l'identité et autorisation de l'entité qui
appelle cette API
"""
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
"""
Verifier la validité des formation
"""
tab_class_ids = []
tab_class_ids_ObjectId = []
if ("tab_class_id" in diction.keys()):
tab_class_ids = str(diction['tab_class_id']).split(",")
for tmp in tab_class_ids:
if (tmp):
is_valide_class = MYSY_GV.dbname['myclass'].count_documents({'_id':ObjectId(tmp), 'valide':'1', 'partner_owner_recid':str(my_partner['recid'])})
if( is_valide_class != 1):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La formation '" + tmp + "' est invalide ")
return False, " La formation '" + tmp + "' est invalide "
tab_class_ids_ObjectId.append(ObjectId(tmp))
"""
Si cette admission à lié à une promotion
"""
if ("class_session_id" in diction.keys() and diction['class_session_id']):
is_valide_promotion = MYSY_GV.dbname['session_formation'].count_documents(
{'_id': ObjectId(str(diction['class_session_id'])),
'partner_owner_recid': str(my_partner['recid']),
'valide': '1'})
if (is_valide_promotion != 1):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " L'identifiant de la promotion est invalide ")
return False, " L'identifiant de la promotion est invalide "
"""
Pour le mode d'animation d'une session de formation, on a :
0 => Présentiel
1 => Distanciel
2 => Hybride
"""
if ("mode_animation" in diction.keys() and diction['mode_animation'] not in ['0', '1', '2', '']):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " Le mode d'animation est invalide ")
return False, " Le mode d'animation est invalide "
"""
Si cette admission à lié à une promotion
"""
if ("class_session_id" in diction.keys() and diction['class_session_id']):
is_valide_promotion = MYSY_GV.dbname['session_formation'].count_documents(
{'_id': ObjectId(str(diction['class_session_id'])),
'partner_owner_recid': str(my_partner['recid']),
'valide': '1'})
if (is_valide_promotion != 1):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " L'identifiant de la promotion est invalide ")
return False, " L'identifiant de la promotion est invalide "
"""
Si cette admission à lié à un process d'admission
"""
if ("process_inscription_id" in diction.keys() and diction['process_inscription_id']):
is_valide_process_admiss = MYSY_GV.dbname['admission_setup'].count_documents(
{'_id': ObjectId(str(diction['process_inscription_id'])),
'partner_owner_recid': str(my_partner['recid']),
'valide': '1'})
if (is_valide_process_admiss != 1):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " L'identifiant du processus d'admission est invalide ")
return False, " L'identifiant du processus d'admission est invalide "
if ("price_by" in diction.keys()):
if( str(diction['price_by']) not in MYSY_GV.TRAINING_PRICE):
mycommon.myprint(str(inspect.stack()[0][3]) + " Le prix par "+str(diction['price_by'])+" n'est valide. Les valeurs autorisées sont "+str(MYSY_GV.TRAINING_PRICE) )
return False, " Le prix par "+str(diction['price_by'])+" n'est valide. Les valeurs autorisées sont "+str(MYSY_GV.TRAINING_PRICE)+" "
if ("location_type" in diction.keys()):
if (str(diction['location_type']).lower() not in MYSY_GV.TRAINING_LOCATION_TYPE):
mycommon.myprint(str(inspect.stack()[0][3]) + " - Le champ 'location_type' est incorrecte.")
return False, "Le champ 'location_type' est incorrect."
if ("entre_scolaire" in diction.keys()):
if (str(diction['entre_scolaire']).lower() not in MYSY_GV.TRAINING_ENTREE_SCOLAIRE):
mycommon.myprint(str(inspect.stack()[0][3]) + " - Le champ 'Entrée scolaire' est incorrecte.")
return False, "Le champ 'Entrée scolaire' est incorrect."
formateur_id = ""
if ("formateur_id" in diction.keys() and diction['formateur_id']):
formateur_id = diction['formateur_id']
# Verification de la validité du formateur (collection employé)
is_formateur_id_ok = MYSY_GV.dbname['ressource_humaine'].count_documents(
{'_id': ObjectId(str(formateur_id)),
'partner_recid': str(my_partner['recid']),
'valide': '1',
'locked': '0'
})
if (is_formateur_id_ok <= 0):
mycommon.myprint(str(inspect.stack()[0][3]) + " - L'identifiant du responsable est invalide")
return False, " L'identifiant du responsable est invalide "
if (datetime.strptime(str(diction['date_debut'])[0:10], '%d/%m/%Y') > datetime.strptime(str(diction['date_fin'])[0:10], '%d/%m/%Y')):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date debut " + str(
diction['date_debut'])[0:10] +
" est postérieure à la date de fin " + str(diction['date_fin'])[0:10] )
return False, " La date debut de formation " + str(diction['date_debut'])[0:10] + \
" est postérieure à la date de fin de formation " + str(diction['date_fin'])[0:10] + " "
# Verification de la cohérence des dates d'inscription si on a bien une date debut et une date de fin
if ("date_debut_inscription" in diction.keys() and "date_fin_inscription" in diction.keys()):
if (str(diction['date_debut_inscription']).strip() != "" and str(
diction['date_fin_inscription']).strip() != ""):
local_status = mycommon.CheckisDate(str(diction['date_debut_inscription'])[0:10])
if (local_status is False):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date_debut_inscription n'est pas au format jj/mm/aaaa ")
return False, " La date de début d'inscription n'est pas au format jj/mm/aaaa "
local_status = mycommon.CheckisDate(str(diction['date_fin_inscription'])[0:10])
if (local_status is False):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date de fin d'inscription n'est pas au format jj/mm/aaaa ")
return False, " La date de fin d'inscription n'est pas au format jj/mm/aaaa "
if (datetime.strptime(str(diction['date_debut_inscription'])[0:10], '%d/%m/%Y') > datetime.strptime(
str(diction['date_fin_inscription'])[0:10], '%d/%m/%Y')):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date de début d'inscription " + str(
diction['date_debut_inscription'])[0:10] + \
" est postérieure à la date de fin d'inscription " + str(diction['date_fin_inscription'])[
0:10] + " ")
return False, " La date de début d'inscription " + str(
diction['date_debut_inscription'])[0:10] + \
" est postérieure à la date de fin d'inscription " + str(
diction['date_fin_inscription'])[0:10] + " "
# Verification : Date de debut inscription n'est pas > date de fin de formation
if (datetime.strptime(str(diction['date_debut_inscription'])[0:10], '%d/%m/%Y') > datetime.strptime(
str(diction['date_fin'])[0:10], '%d/%m/%Y')):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date de debut d'inscription " + str(diction['date_debut_inscription']) + " est postérieure à la date de fin de formation " + str(
diction['date_fin']))
return False, " La date de debut d'inscription " + str(
diction['date_debut_inscription'])[0:10] + " est postérieure à la date de fin de formation " + str(
diction['date_fin'])[0:10] + " "
# Verification : Date de fin inscription n'est pas > date de fin de formation
if (datetime.strptime(str(diction['date_fin_inscription'])[0:10], '%d/%m/%Y') > datetime.strptime(
str(diction['date_fin'])[0:10], '%d/%m/%Y')):
mycommon.myprint(
str(inspect.stack()[0][3]) + " La date de fin d'inscription " + str(diction['date_fin_inscription'])[0:10] + " est postérieure à la date de fin de la formation " + str(diction['date_fin'])[0:10])
return False, " La date de fin d'inscription " + str(diction['date_fin_inscription'])[0:10] + " est postérieure à la date de fin de la formation " + str(
diction['date_fin'])[0:10] + " "
new_data = diction
del diction['token']
# Initialisation des champs non envoyés à vide
for val in field_list:
if val not in diction.keys():
new_data[str(val)] = ""
new_data['valide'] = "1"
new_data['locked'] = "0"
new_data['creation_date'] = str(datetime.now())
new_data['creation_by'] = str(my_partner['_id'])
new_data['partner_owner_recid'] = str(my_partner['recid'])
new_data['valide'] = "1"
new_data['locked'] = "0"
inserted_id = MYSY_GV.dbname['admission_session'].insert_one(new_data).inserted_id
if (not inserted_id):
mycommon.myprint(
" Impossible de créer la session d'admission (2) ")
return False, " Impossible de créer la session d'admission (2) "
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
history_event_dict = {}
history_event_dict['token'] = str(token)
history_event_dict['related_collection'] = "admission_session"
history_event_dict['related_collection_recid'] = str(inserted_id)
history_event_dict['action_date'] = str(now)
history_event_dict['action_description'] = "Création "
local_status, local_retval = mycommon.Collection_Historique.Add_Historique_Event(history_event_dict)
if (local_status is False):
mycommon.myprint(
" WARNING : Impossible de logguer l'historique pour l'évènement : " + str(history_event_dict))
return True, " La session d'admission a été correctement ajoutée"
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
return False, " Impossible de créer la session d'admission (2) "
"""
Mise à jour d'une session d'admission
"""
def Update_Admission_Session(diction):
try:
diction = mycommon.strip_dictionary(diction)
"""
Verification des input acceptés
"""
field_list = ['token', '_id', 'date_debut', 'date_fin', 'nb_participant', 'adresse',
'code_postal', 'ville', 'code_session',
'tab_class_id', 'session_status', 'date_debut_inscription', 'date_fin_inscription',
'attestation_certif', "distantiel", "presentiel", "prix_session", 'contenu_ftion',
'session_ondemande', 'source', 'session_etape', 'pays', 'formateur_id',
'titre', 'location_type', 'site_formation_id', 'mode_animation', 'archive',
'entre_scolaire',
'memo', 'comment', 'class_session_id', 'process_inscription_id']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(
inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
return False, " Les informations fournies sont incorrectes"
"""
Verification des champs obligatoires
"""
field_list_obligatoire = ['token', '_id',]
for val in field_list_obligatoire:
if val not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
return False, " Les informations fournies sont incorrectes"
"""
Verification de l'identité et autorisation de l'entité qui
appelle cette API
"""
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
new_data = diction
# Verifier que la configuration de l'admission
is_existe_admis_session = MYSY_GV.dbname['admission_session'].count_documents(
{'_id': ObjectId(str(diction['_id'])),
'valide': '1',
'partner_owner_recid': str(my_partner['recid'])})
if (is_existe_admis_session < 0):
mycommon.myprint(
str(inspect.stack()[0][3]) + " L'identifiant de la session d'admission est invalide ")
return False, " L'identifiant de la session d'admission est invalide "
"""
Verifier la validité des formation
"""
tab_class_ids = []
tab_class_ids_ObjectId = []
if ("tab_class_id" in diction.keys()):
tab_class_ids = str(diction['tab_class_id']).split(",")
for tmp in tab_class_ids:
if (tmp):
is_valide_class = MYSY_GV.dbname['myclass'].count_documents(
{'_id': ObjectId(tmp), 'valide': '1', 'partner_owner_recid': str(my_partner['recid'])})
if (is_valide_class != 1):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La formation '" + tmp + "' est invalide ")
return False, " La formation '" + tmp + "' est invalide "
tab_class_ids_ObjectId.append(ObjectId(tmp))
"""
Pour le mode d'animation d'une session de formation, on a :
0 => Présentiel
1 => Distanciel
2 => Hybride
"""
if ("mode_animation" in diction.keys() and diction['mode_animation'] not in ['0', '1', '2', '']):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " Le mode d'animation est invalide ")
return False, " Le mode d'animation est invalide "
"""
Si cette admission à lié à une promotion
"""
if( "class_session_id" in diction.keys() and diction['class_session_id']):
is_valide_promotion = MYSY_GV.dbname['session_formation'].count_documents({'_id':ObjectId(str(diction['class_session_id'])),
'partner_owner_recid':str(my_partner['recid']),
'valide':'1'})
if( is_valide_promotion != 1):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " L'identifiant de la promotion est invalide ")
return False, " L'identifiant de la promotion est invalide "
"""
Si cette admission à lié à un process d'admission
"""
if ("process_inscription_id" in diction.keys() and diction['process_inscription_id']):
is_valide_process_admiss = MYSY_GV.dbname['admission_setup'].count_documents(
{'_id': ObjectId(str(diction['process_inscription_id'])),
'partner_owner_recid': str(my_partner['recid']),
'valide': '1'})
if (is_valide_process_admiss != 1):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " L'identifiant du processus d'admission est invalide ")
return False, " L'identifiant du processus d'admission est invalide "
if ("price_by" in diction.keys()):
if (str(diction['price_by']) not in MYSY_GV.TRAINING_PRICE):
mycommon.myprint(str(inspect.stack()[0][3]) + " Le prix par " + str(
diction['price_by']) + " n'est valide. Les valeurs autorisées sont " + str(MYSY_GV.TRAINING_PRICE))
return False, " Le prix par " + str(
diction['price_by']) + " n'est valide. Les valeurs autorisées sont " + str(
MYSY_GV.TRAINING_PRICE) + " "
if ("location_type" in diction.keys()):
if (str(diction['location_type']).lower() not in MYSY_GV.TRAINING_LOCATION_TYPE):
mycommon.myprint(str(inspect.stack()[0][3]) + " - Le champ 'location_type' est incorrecte.")
return False, "Le champ 'location_type' est incorrect."
if ("entre_scolaire" in diction.keys()):
if (str(diction['entre_scolaire']).lower() not in MYSY_GV.TRAINING_ENTREE_SCOLAIRE):
mycommon.myprint(str(inspect.stack()[0][3]) + " - Le champ 'Entrée scolaire' est incorrecte.")
return False, "Le champ 'Entrée scolaire' est incorrect."
if ("formateur_id" in diction.keys() and diction['formateur_id']):
formateur_id = diction['formateur_id']
# Verification de la validité du formateur (collection employé)
is_formateur_id_ok = MYSY_GV.dbname['ressource_humaine'].count_documents(
{'_id': ObjectId(str(formateur_id)),
'partner_recid': str(my_partner['recid']),
'valide': '1',
'locked': '0'
})
if (is_formateur_id_ok <= 0):
mycommon.myprint(str(inspect.stack()[0][3]) + " - L'identifiant du responsable est invalide")
return False, " L'identifiant du responsable est invalide "
if (datetime.strptime(str(diction['date_debut'])[0:10], '%d/%m/%Y') > datetime.strptime(
str(diction['date_fin'])[0:10], '%d/%m/%Y')):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date debut " + str(
diction['date_debut'])[0:10] +
" est postérieure à la date de fin " + str(diction['date_fin'])[0:10])
return False, " La date debut de formation " + str(diction['date_debut'])[0:10] + \
" est postérieure à la date de fin de formation " + str(diction['date_fin'])[0:10] + " "
# Verification de la cohérence des dates d'inscription si on a bien une date debut et une date de fin
if ("date_debut_inscription" in diction.keys() and "date_fin_inscription" in diction.keys()):
if (str(diction['date_debut_inscription']).strip() != "" and str(
diction['date_fin_inscription']).strip() != ""):
local_status = mycommon.CheckisDate(str(diction['date_debut_inscription'])[0:10])
if (local_status is False):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date_debut_inscription n'est pas au format jj/mm/aaaa ")
return False, " La date de début d'inscription n'est pas au format jj/mm/aaaa "
local_status = mycommon.CheckisDate(str(diction['date_fin_inscription'])[0:10])
if (local_status is False):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date de fin d'inscription n'est pas au format jj/mm/aaaa ")
return False, " La date de fin d'inscription n'est pas au format jj/mm/aaaa "
if (datetime.strptime(str(diction['date_debut_inscription'])[0:10], '%d/%m/%Y') > datetime.strptime(
str(diction['date_fin_inscription'])[0:10], '%d/%m/%Y')):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date de début d'inscription " + str(
diction['date_debut_inscription'])[0:10] + \
" est postérieure à la date de fin d'inscription " + str(diction['date_fin_inscription'])[
0:10] + " ")
return False, " La date de début d'inscription " + str(
diction['date_debut_inscription'])[0:10] + \
" est postérieure à la date de fin d'inscription " + str(
diction['date_fin_inscription'])[0:10] + " "
# Verification : Date de debut inscription n'est pas > date de fin de formation
if (datetime.strptime(str(diction['date_debut_inscription'])[0:10], '%d/%m/%Y') > datetime.strptime(
str(diction['date_fin'])[0:10], '%d/%m/%Y')):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date de debut d'inscription " + str(diction[
'date_debut_inscription']) + " est postérieure à la date de fin de formation " + str(
diction['date_fin']))
return False, " La date de debut d'inscription " + str(
diction['date_debut_inscription'])[
0:10] + " est postérieure à la date de fin de formation " + str(
diction['date_fin'])[0:10] + " "
# Verification : Date de fin inscription n'est pas > date de fin de formation
if (datetime.strptime(str(diction['date_fin_inscription'])[0:10], '%d/%m/%Y') > datetime.strptime(
str(diction['date_fin'])[0:10], '%d/%m/%Y')):
mycommon.myprint(
str(inspect.stack()[0][3]) + " La date de fin d'inscription " + str(
diction['date_fin_inscription'])[
0:10] + " est postérieure à la date de fin de la formation " + str(
diction['date_fin'])[0:10])
return False, " La date de fin d'inscription " + str(diction['date_fin_inscription'])[
0:10] + " est postérieure à la date de fin de la formation " + str(
diction['date_fin'])[0:10] + " "
local_id = str(diction['_id'])
del diction['token']
del diction['_id']
new_data['update_date'] = str(datetime.now())
new_data['update_by'] = str(my_partner['_id'])
data_cle = {}
data_cle['partner_owner_recid'] = str(my_partner['recid'])
data_cle['_id'] = ObjectId(local_id)
result = MYSY_GV.dbname['admission_session'].find_one_and_update(
data_cle,
{"$set": new_data},
upsert=False,
return_document=ReturnDocument.AFTER
)
if ("_id" not in result.keys()):
mycommon.myprint(
" Impossible de mettre à jour la session d'admission (2) ")
return False, " Impossible de mettre à jour la session d'admission (2) "
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
history_event_dict = {}
history_event_dict['token'] = str(token)
history_event_dict['related_collection'] = "admission_session"
history_event_dict['related_collection_recid'] = str(local_id)
history_event_dict['action_date'] = str(now)
history_event_dict['action_description'] = "Mise à jour "
local_status, local_retval = mycommon.Collection_Historique.Add_Historique_Event(history_event_dict)
if (local_status is False):
mycommon.myprint(
" WARNING : Impossible de logguer l'historique pour l'évènement : " + str(history_event_dict))
return True, " La session a été correctement mise à jour"
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
return False, " Impossible de mettre à jour la session d'admission "
"""
Suppression d'une session d'admission
regles :
- supprimer les inscrits
"""
def Delete_Admission_Session(diction):
try:
diction = mycommon.strip_dictionary(diction)
"""
Verification des input acceptés
"""
field_list = ['token', '_id',]
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(
inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
return False, " Les informations fournies sont incorrectes"
"""
Verification des champs obligatoires
"""
field_list_obligatoire = ['token', '_id',]
for val in field_list_obligatoire:
if val not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
return False, " Les informations fournies sont incorrectes"
"""
Verification de l'identité et autorisation de l'entité qui
appelle cette API
"""
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
delete = MYSY_GV.dbname['admission_session'].delete_one({'_id': ObjectId(str(diction['_id'])),
'partner_owner_recid': str(my_partner['recid']),
}, )
return True, " La session d'admission a été correctement supprimée "
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
return False, " Impossible de supprimer la session d'admission "
"""
Recuperer la liste des session d'admission d'un partenaire
"""
def Get_List_Admission_Session(diction):
try:
diction = mycommon.strip_dictionary(diction)
"""
Verification des input acceptés
"""
field_list = ['token', ]
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(
inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas")
return False, " Les informations fournies sont incorrectes",
"""
Verification des champs obligatoires
"""
field_list_obligatoire = ['token', ]
for val in field_list_obligatoire:
if val not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
return False, " Les informations fournies sont incorrectes",
"""
Verification de l'identité et autorisation de l'entité qui
appelle cette API
"""
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
"""
Clés de mise à jour
"""
data_cle = {}
data_cle['partner_owner_recid'] = str(my_partner['recid'])
data_cle['valide'] = "1"
data_cle['locked'] = "0"
RetObject = []
val_tmp = 0
for retval in MYSY_GV.dbname['admission_session'].find(data_cle).sort([("_id", pymongo.DESCENDING), ]):
user = retval
user['id'] = str(val_tmp)
val_tmp = val_tmp + 1
class_session_id_code = ""
if( "class_session_id" in retval.keys() and retval['class_session_id'] ):
promo_data = MYSY_GV.dbname['session_formation'].find_one({'_id':ObjectId(str(retval['class_session_id'])),
'partner_owner_recid':str(my_partner['recid']),
'valide':'1'})
if(promo_data and "code_session" in promo_data.keys() ):
class_session_id_code = promo_data['code_session']
user['class_session_id_code'] = class_session_id_code
process_inscription_id_code = ""
if ("process_inscription_id" in retval.keys() and retval['process_inscription_id']):
process_admiss_data = MYSY_GV.dbname['admission_setup'].find_one(
{'_id': ObjectId(str(retval['process_inscription_id'])),
'partner_owner_recid': str(my_partner['recid']),
'valide': '1'})
if (process_admiss_data and "code" in process_admiss_data.keys()):
process_inscription_id_code = process_admiss_data['code']
user['process_inscription_id_code'] = process_inscription_id_code
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) + " - Line : " + str(exc_tb.tb_lineno))
return False, " Impossible de récupérer la liste des sessions d'admission "
"""
Recuperer les données d'une session d'admission donnée
"""
def Get_Given_Admission_Session(diction):
try:
diction = mycommon.strip_dictionary(diction)
"""
Verification des input acceptés
"""
field_list = ['token', '_id']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(
inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas")
return False, " Les informations fournies sont incorrectes",
"""
Verification des champs obligatoires
"""
field_list_obligatoire = ['token', '_id' ]
for val in field_list_obligatoire:
if val not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
return False, " Les informations fournies sont incorrectes",
"""
Verification de l'identité et autorisation de l'entité qui
appelle cette API
"""
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
"""
Clés de mise à jour
"""
data_cle = {}
data_cle['partner_owner_recid'] = str(my_partner['recid'])
data_cle['valide'] = "1"
data_cle['locked'] = "0"
data_cle['_id'] = ObjectId(str(diction['_id']))
RetObject = []
val_tmp = 0
for retval in MYSY_GV.dbname['admission_session'].find(data_cle):
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) + " - Line : " + str(exc_tb.tb_lineno))
return False, " Impossible de récupérer les données de la session d'admission "
"""
Inscrire une personne à une session d'admission
"""
def Add_Stagiaire_To_Admission_Session(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 = ['token', 'nom', 'prenom', 'email', 'telephone', 'modefinancement',
'session_id', 'employeur', 'status', 'price',
'client_rattachement_id', 'adresse', 'code_postal', 'ville', 'pays',
'type_apprenant', 'civilite', 'date_naissance', 'memo', 'comment',
"num_secu", "is_rgpd", "situation_famille", "piece_identite_type", "piece_identite_num",
"type_mobilite", "telephone_bis", "nationalite", "is_handicap", "is_handicap", "is_droit_image",
'naissance_lieu', 'naissance_departement', 'naissance_pays', 'session_etape'
]
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(inspect.stack()[0][
3]) + " - Le champ '" + val + "' n'est pas autorisé")
return False, "Toutes les informations fournies ne sont pas valables"
"""
Verification de la liste des champs obligatoires
"""
field_list_obligatoire = ['nom', 'prenom', 'email', 'telephone',
'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 la liste des arguments ")
return False, "Impossible de créer le stagiaire. La valeur '" + val + "' n'est pas presente dans la liste des arguments"
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
"""
Verififier l'existance et la valididé de la session
"""
my_session_data_qry = {"_id": ObjectId(str(diction['session_id'])), 'valide': '1'}
# print(" AddStagiairetoClass my_session_data_qry = ", my_session_data_qry)
my_session_data = MYSY_GV.dbname['admission_session'].find_one(my_session_data_qry)
if (my_session_data is None):
mycommon.myprint(
str(inspect.stack()[0][3]) + " L'identifiant de la session est invalide ")
return False, " L'identifiant de la session est invalide"
"""
Verifier qu'il n'y pas déjà une presonne inscrite avec le meme email pour la meme session
"""
is_inscrit_exist = MYSY_GV.dbname['admission_session_inscrit'].count_documents({'email':diction['email'],
'session_id':diction['session_id'],
'partner_owner_recid':my_partner['recid']})
if( is_inscrit_exist > 0 ):
mycommon.myprint(
str(inspect.stack()[0][3]) + " Une personne est déjà inscrite à cette session avec la même adresse email ")
return False, " Une personne est déjà inscrite à cette session avec la même adresse email "
"""
Verifier la validité de l'etape
"""
if ("session_etape" in diction.keys() and str(diction['session_etape'])):
session_etape_id = MYSY_GV.dbname['admission_setup_etape'].count_documents(
{"_id": ObjectId(str(diction['session_etape'])),
'valide': '1', 'partner_owner_recid': str(my_partner['recid'])})
if (session_etape_id != 1):
mycommon.myprint(
str(inspect.stack()[0][3]) + " L'identifiant de l'etape est invalide ")
return False, " L'identifiant de l'etape est invalide "
if ("is_handicap" in diction.keys() and str(diction['is_handicap']) not in ['0', '1', '']):
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ 'is_handicap' est invalide ")
return False, " Le champ 'is_handicap' est invalide "
if ("is_droit_image" in diction.keys() and str(diction['is_droit_image']) not in ['0', '1', '']):
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ 'is_droit_image' est invalide ")
return False, " Le champ 'is_droit_image' est invalide "
if ("is_rgpd" in diction.keys() and str(diction['is_rgpd']) not in ['0', '1', '']):
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ 'is_rgpd' est invalide ")
return False, " Le champ 'is_rgpd' est invalide "
if ("date_naissance" in diction.keys()):
if diction['date_naissance']:
date_naissance = str(diction['date_naissance']).strip()
local_status = mycommon.CheckisDate(date_naissance)
if (local_status is False):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date de naissance n'est pas au format 'jj/mm/aaaa' ")
return False, " La date de naissance n'est pas au format 'jj/mm/aaaa' "
if ("type_apprenant" in diction.keys() and diction['type_apprenant']):
type_apprenant = str(mycommon.tryInt(diction['type_apprenant']))
if (type_apprenant not in MYSY_GV.INSCRIPTION_TYPE_APPRENANT):
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le type d'apprenant est invalide ")
return False, " Le type d'apprenant est invalide. Valeurs autorisées" + str(
MYSY_GV.INSCRIPTION_TYPE_APPRENANT)
new_data = diction
del diction['token']
# Initialisation des champs non envoyés à vide
for val in field_list:
if val not in diction.keys():
new_data[str(val)] = ""
new_data['valide'] = "1"
new_data['locked'] = "0"
new_data['creation_date'] = str(datetime.now())
new_data['creation_by'] = str(my_partner['_id'])
new_data['partner_owner_recid'] = str(my_partner['recid'])
new_data['valide'] = "1"
new_data['locked'] = "0"
if ("date_naissance" in new_data.keys() and new_data['date_naissance'] == ""):
new_data['date_naissance'] = "01/01/1900"
if ("date_naissance" not in new_data.keys()):
new_data['date_naissance'] = "01/01/1900"
inserted_data = MYSY_GV.dbname['admission_session_inscrit'].insert_one(new_data)
if (not inserted_data.inserted_id):
mycommon.myprint(
" Impossible de créer la session d'admission (2) ")
return False, " Impossible de créer la session d'admission (2) "
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
history_event_dict = {}
history_event_dict['token'] = str(token)
history_event_dict['related_collection'] = "admission_session_inscrit"
history_event_dict['related_collection_recid'] = str(inserted_data.inserted_id)
history_event_dict['action_date'] = str(now)
history_event_dict['action_description'] = "Inscription de la personnes "+str(new_data['nom'])+" "+str(new_data['prenom'])+" "+str(inserted_data.inserted_id)
local_status, local_retval = mycommon.Collection_Historique.Add_Historique_Event(history_event_dict)
if (local_status is False):
mycommon.myprint(
" WARNING : Impossible de logguer l'historique pour l'évènement : " + str(history_event_dict))
return True, " La personne a été correctement ajouté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'ajouter la personne"
"""
Mettre à jour le statut d'une personne à une session d'admission
"""
def Update_Stagiaire_Only_Status_Admission_Session(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 = ['token', '_id', 'new_session_etape_code' ]
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(inspect.stack()[0][
3]) + " - Le champ '" + val + "' n'est pas autorisé")
return False, "Toutes les informations fournies ne sont pas valables"
"""
Verification de la liste des champs obligatoires
"""
field_list_obligatoire = ['token', '_id', 'new_session_etape_code' ]
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 la liste des arguments ")
return False, "Impossible de créer le stagiaire. La valeur '" + val + "' n'est pas presente dans la liste des arguments"
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
"""
Verifier la validé de l'inscrit
"""
is_existe_inscrit = MYSY_GV.dbname['admission_session_inscrit'].count_documents(
{'_id': ObjectId(str(diction['_id'])),
'valide': '1',
'partner_owner_recid': str(my_partner['recid'])})
if (is_existe_inscrit != 1):
mycommon.myprint(
str(inspect.stack()[0][3]) + " L'identifiant de la personne est invalide ")
return False, " L'identifiant de la personne est invalide "
"""
Verifier la validité de l'etape
"""
session_etape_id = MYSY_GV.dbname['admission_setup_etape'].count_documents({"code":str(diction['new_session_etape_code']),
'valide':'1', 'partner_owner_recid': str(my_partner['recid'])})
if (session_etape_id <= 0):
mycommon.myprint(
str(inspect.stack()[0][3]) + " L'identifiant de l'etape est invalide ")
return False, " L'identifiant de l'etape est invalide "
session_etape_id_data = MYSY_GV.dbname['admission_setup_etape'].find_one({"code":str(diction['new_session_etape_code']),
'valide':'1', 'partner_owner_recid': str(my_partner['recid'])})
local_id = str(diction['_id'])
del diction['token']
del diction['_id']
new_data = {}
new_data['update_by'] = str(my_partner['_id'])
new_data['update_date'] = str(datetime.now())
new_data['session_etape'] = str(session_etape_id_data['_id'])
data_cle = {}
data_cle['partner_owner_recid'] = str(my_partner['recid'])
data_cle['_id'] = ObjectId(local_id)
data_cle['valide'] = "1"
data_cle['locked'] = "0"
result = MYSY_GV.dbname['admission_session_inscrit'].find_one_and_update(
data_cle,
{"$set": new_data},
upsert=False,
return_document=ReturnDocument.AFTER
)
if (not result or "_id" not in result.keys()):
mycommon.myprint(
" Impossible de mettre à jour la personne (2) ")
return False, " Impossible de mettre à jour la personne (2) "
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
history_event_dict = {}
history_event_dict['token'] = str(token)
history_event_dict['related_collection'] = "admission_session_inscrit"
history_event_dict['related_collection_recid'] = str(local_id)
history_event_dict['action_date'] = str(now)
history_event_dict['action_description'] = "Changement étape pour " + str(result['nom']) + " " + str(
result['prenom']) + " " + str(result['_id'])
local_status, local_retval = mycommon.Collection_Historique.Add_Historique_Event(history_event_dict)
if (local_status is False):
mycommon.myprint(
" WARNING : Impossible de logguer l'historique pour l'évènement : " + str(history_event_dict))
return True, " La personne a été correctement ajouté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 de mettre à jour la personne "
"""
Mettre à jour une personne à une session d'admission
"""
def Update_Stagiaire_To_Admission_Session(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 = ['token', '_id', 'nom', 'prenom', 'email', 'telephone', 'modefinancement',
'session_id', 'employeur', 'status', 'price',
'client_rattachement_id', 'adresse', 'code_postal', 'ville', 'pays',
'type_apprenant', 'civilite', 'date_naissance', 'memo', 'comment',
"num_secu", "is_rgpd", "situation_famille", "piece_identite_type", "piece_identite_num",
"type_mobilite", "telephone_bis", "nationalite", "is_handicap", "is_droit_image",
'naissance_lieu', 'naissance_departement', 'naissance_pays', 'session_etape'
]
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(inspect.stack()[0][
3]) + " - Le champ '" + val + "' n'est pas autorisé")
return False, "Toutes les informations fournies ne sont pas valables"
"""
Verification de la liste des champs obligatoires
"""
field_list_obligatoire = ['nom', 'prenom', 'email', 'telephone',
'session_id', 'token', '_id']
for val in field_list_obligatoire:
if val not in diction:
mycommon.myprint(
str(inspect.stack()[0][
3]) + " - : La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
return False, "Impossible de créer le stagiaire. La valeur '" + val + "' n'est pas presente dans la liste des arguments"
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
"""
Verifier la validé de l'inscrit
"""
is_existe_inscrit = MYSY_GV.dbname['admission_session_inscrit'].count_documents(
{'_id': ObjectId(str(diction['_id'])),
'valide': '1',
'partner_owner_recid': str(my_partner['recid'])})
if (is_existe_inscrit != 1):
mycommon.myprint(
str(inspect.stack()[0][3]) + " L'identifiant de la personne est invalide ")
return False, " L'identifiant de la personne est invalide "
"""
Verififier l'existance et la valididé de la session
"""
my_session_data_qry = {"_id": ObjectId(str(diction['session_id'])), 'valide': '1'}
# print(" AddStagiairetoClass my_session_data_qry = ", my_session_data_qry)
my_session_data = MYSY_GV.dbname['admission_session'].find_one(my_session_data_qry)
if (my_session_data is None):
mycommon.myprint(
str(inspect.stack()[0][3]) + " L'identifiant de la session est invalide ")
return False, " L'identifiant de la session est invalide"
"""
Verifier la validité de l'etape
"""
if("session_etape" in diction.keys() and str(diction['session_etape']) ):
session_etape_id = MYSY_GV.dbname['admission_setup_etape'].count_documents(
{"_id": ObjectId(str(diction['session_etape'])),
'valide': '1', 'partner_owner_recid': str(my_partner['recid'])})
if (session_etape_id != 1):
mycommon.myprint(
str(inspect.stack()[0][3]) + " L'identifiant de l'etape est invalide ")
return False, " L'identifiant de l'etape est invalide "
if ("is_handicap" in diction.keys() and str(diction['is_handicap']) not in ['0', '1', '']):
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ 'is_handicap' est invalide ")
return False, " Le champ 'is_handicap' est invalide "
if ("is_droit_image" in diction.keys() and str(diction['is_droit_image']) not in ['0', '1', '']):
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ 'is_droit_image' est invalide ")
return False, " Le champ 'is_droit_image' est invalide "
if ("is_rgpd" in diction.keys() and str(diction['is_rgpd']) not in ['0', '1', '']):
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ 'is_rgpd' est invalide ")
return False, " Le champ 'is_rgpd' est invalide "
if ("date_naissance" in diction.keys()):
if diction['date_naissance']:
date_naissance = str(diction['date_naissance']).strip()
local_status = mycommon.CheckisDate(date_naissance)
if (local_status is False):
mycommon.myprint(
str(inspect.stack()[0][
3]) + " La date de naissance n'est pas au format 'jj/mm/aaaa' ")
return False, " La date de naissance n'est pas au format 'jj/mm/aaaa' "
if ("type_apprenant" in diction.keys() and diction['type_apprenant']):
type_apprenant = str(mycommon.tryInt(diction['type_apprenant']))
if (type_apprenant not in MYSY_GV.INSCRIPTION_TYPE_APPRENANT):
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le type d'apprenant est invalide ")
return False, " Le type d'apprenant est invalide. Valeurs autorisées" + str(
MYSY_GV.INSCRIPTION_TYPE_APPRENANT)
local_id = str(diction['_id'])
del diction['token']
del diction['_id']
new_data = diction
new_data['update_date'] = str(datetime.now())
new_data['update_by'] = str(my_partner['_id'])
if( "date_naissance" in new_data.keys() and new_data['date_naissance'] == ""):
new_data['date_naissance'] = "01/01/1900"
if( "date_naissance" not in new_data.keys() ):
new_data['date_naissance'] = "01/01/1900"
data_cle = {}
data_cle['partner_owner_recid'] = str(my_partner['recid'])
data_cle['_id'] = ObjectId(local_id)
data_cle['valide'] = "1"
data_cle['locked'] = "0"
print(" ### data_cle = ", data_cle)
result = MYSY_GV.dbname['admission_session_inscrit'].find_one_and_update(
data_cle,
{"$set": new_data},
upsert=False,
return_document=ReturnDocument.AFTER
)
if (not result or "_id" not in result.keys()):
mycommon.myprint(
" Impossible de mettre à jour la personne (2) ")
return False, " Impossible de mettre à jour la personne (2) "
now = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
history_event_dict = {}
history_event_dict['token'] = str(token)
history_event_dict['related_collection'] = "admission_session_inscrit"
history_event_dict['related_collection_recid'] = str(local_id)
history_event_dict['action_date'] = str(now)
history_event_dict['action_description'] = "Inscription de la personnes " + str(result['nom']) + " " + str(
result['prenom']) + " " + str(result['_id'])
local_status, local_retval = mycommon.Collection_Historique.Add_Historique_Event(history_event_dict)
if (local_status is False):
mycommon.myprint(
" WARNING : Impossible de logguer l'historique pour l'évènement : " + str(history_event_dict))
return True, " La personne a été correctement ajouté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 de mettre à jour la personne "
"""
Suppression de l'inscription d'une personne à une session d'admission
"""
def Delete_Stagiaire_To_Admission_Session(diction):
try:
diction = mycommon.strip_dictionary(diction)
"""
Verification des input acceptés
"""
field_list = ['token', '_id' ]
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(
inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas autorisé")
return False, " Les informations fournies sont incorrectes"
"""
Verification des champs obligatoires
"""
field_list_obligatoire = ['token', '_id' ]
for val in field_list_obligatoire:
if val not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
return False, " Les informations fournies sont incorrectes"
"""
Verification de l'identité et autorisation de l'entité qui
appelle cette API
"""
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
delete = MYSY_GV.dbname['admission_session_inscrit'].delete_one({'_id': ObjectId(str(diction['_id'])),
'partner_owner_recid': str(my_partner['recid']),
}, )
return True, " L'inscription a été correctement supprimée"
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
return False, " Impossible de supprimer l'inscription "
"""
Recuperer la liste des personne à une session d'admission
"""
def Get_List_Stagiaire_Admission_Session(diction):
try:
diction = mycommon.strip_dictionary(diction)
"""
Verification des input acceptés
"""
field_list = ['token', 'session_id']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(
inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas")
return False, " Les informations fournies sont incorrectes",
"""
Verification des champs obligatoires
"""
field_list_obligatoire = ['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 la liste des arguments ")
return False, " Les informations fournies sont incorrectes",
"""
Verification de l'identité et autorisation de l'entité qui
appelle cette API
"""
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
"""
Clés de mise à jour
"""
data_cle = {}
data_cle['partner_owner_recid'] = str(my_partner['recid'])
data_cle['session_id'] = str(diction['session_id'])
data_cle['valide'] = "1"
data_cle['locked'] = "0"
RetObject = []
val_tmp = 0
for retval in MYSY_GV.dbname['admission_session_inscrit'].find(data_cle).sort([("_id", pymongo.DESCENDING), ]):
user = retval
user['id'] = str(val_tmp)
val_tmp = val_tmp + 1
if ("date_naissance" not in retval.keys() or retval['date_naissance'] == ""):
retval['date_naissance'] = "01/01/1900"
if ("civilite" not in retval.keys() or retval['civilite'] == ""):
retval['civilite'] = "neutre"
age = relativedelta( date.today(), datetime.strptime(str(retval['date_naissance']), '%d/%m/%Y') )
retval['age'] = str(age.years)
session_etape_code = ""
if( "session_etape" in retval.keys() and retval['session_etape'] ):
admiss_session_etape_data = MYSY_GV.dbname['admission_setup_etape'].find_one(({'_id':ObjectId(str(retval['session_etape'])),
'valide':'1',
'partner_owner_recid':str(my_partner['recid'])}))
if( admiss_session_etape_data and "code" in admiss_session_etape_data.keys()):
session_etape_code = admiss_session_etape_data['code']
retval['session_etape_code'] = str(session_etape_code)
local_status, local_retval = Internal_Get_Pourcentage_Candidat_Document({'partner_recid':str(my_partner['recid']), 'inscrit_id':str(retval['_id'])})
if(local_status ):
retval['document_satatus'] = local_retval
if( "pourcentage_accepted" in local_retval.keys()):
retval['document_pourcentage_accepted'] = str(local_retval['pourcentage_accepted'])
if ("pourcentage_send" in local_retval.keys()):
retval['taux_document_pourcentage_received'] = str(local_retval['pourcentage_send'])
else:
retval['document_pourcentage_accepted'] = "0"
retval['taux_document_pourcentage_received'] = "0"
if( retval['document_pourcentage_accepted'] != "1"):
retval['document_alert_message'] = "Tous les documents ne sont pas validés"
else:
retval['document_alert_message'] = ""
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) + " - Line : " + str(exc_tb.tb_lineno))
return False, " Impossible de récupérer la liste des inscrits"
"""
Recuperer les données d'une personne inscrite à une session d'admission
"""
def Get_Given_Stagiaire_Admission_Session(diction):
try:
diction = mycommon.strip_dictionary(diction)
"""
Verification des input acceptés
"""
field_list = ['token', '_id']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(
inspect.stack()[0][3]) + " Le champ '" + val + "' n'existe pas")
return False, " Les informations fournies sont incorrectes",
"""
Verification des champs obligatoires
"""
field_list_obligatoire = ['token', '_id' ]
for val in field_list_obligatoire:
if val not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans la liste des arguments ")
return False, " Les informations fournies sont incorrectes",
"""
Verification de l'identité et autorisation de l'entité qui
appelle cette API
"""
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
"""
Clés de mise à jour
"""
data_cle = {}
data_cle['partner_owner_recid'] = str(my_partner['recid'])
data_cle['valide'] = "1"
data_cle['locked'] = "0"
data_cle['_id'] = ObjectId(str(diction['_id']))
RetObject = []
val_tmp = 0
print(" ## data_cle = ", data_cle)
for retval in MYSY_GV.dbname['admission_session_inscrit'].find(data_cle):
user = retval
user['id'] = str(val_tmp)
if ("date_naissance" not in retval.keys() or retval['date_naissance'] == ""):
retval['date_naissance'] = "01/01/1900"
if ("civilite" not in retval.keys() or retval['civilite'] == ""):
retval['civilite'] = "neutre"
age = relativedelta(date.today(), datetime.strptime(str(retval['date_naissance']), '%d/%m/%Y'))
retval['age'] = str(age.years)
session_etape_code = ""
if ("session_etape" in retval.keys() and retval['session_etape']):
admiss_session_etape_data = MYSY_GV.dbname['admission_setup_etape'].find_one(
({'_id': ObjectId(str(retval['session_etape'])),
'valide': '1',
'partner_owner_recid': str(my_partner['recid'])}))
if (admiss_session_etape_data and "code" in admiss_session_etape_data.keys()):
session_etape_code = admiss_session_etape_data['code']
retval['session_etape_code'] = str(session_etape_code)
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) + " - Line : " + str(exc_tb.tb_lineno))
return False, " Impossible de récupérer les données de l'inscrit "
"""
Cette fonction ajoute ou met à jour une image de profil d'un inscrit à une session d'admission
"""
def Add_Update_Inscrit_Admiss_Session_Image(file_img=None, Folder=None, diction=None):
try:
# Dictionnaire des champs utilisables
'''
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
# field_list.
'''
field_list = ['token', 'file_img_recid', 'inscrit_id' ]
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(str(inspect.stack()[0][3]) + " : Le champ '"+val + "' n'est pas autorisé ")
return False, " Le champ '" + val + "' n'est pas accepté "
'''
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
On controle que les champs obligatoires sont presents dans la liste
'''
field_list_obligatoire = ['token', 'file_img_recid', 'inscrit_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 la liste des arguments ")
return False, " La valeur '" + val + "' n'est pas presente dans la liste des arguments "
# recuperation des paramettre
token = ""
if ("token" in diction.keys()):
if diction['token']:
token = diction['token']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
# Verifier que l'apprenant est valide
is_inscrit_id_valide_count = MYSY_GV.dbname['admission_session_inscrit'].count_documents({'_id':ObjectId(diction['inscrit_id']),
'valide':'1',
'locked':'0',
'partner_owner_recid':str(my_partner['recid'])})
if( is_inscrit_id_valide_count != 1):
mycommon.myprint(str(inspect.stack()[0][3]) + " L'identifiant de l'inscrit est invalide ")
return False, " L'identifiant de l'inscrit est invalide "
inscrit_id_data = MYSY_GV.dbname['admission_session_inscrit'].find_one(
{'_id': ObjectId(diction['inscrit_id']),
'valide': '1',
'locked': '0',
'partner_owner_recid': str(my_partner['recid'])})
if( file_img ):
recordimage_diction = {}
recordimage_diction['token'] = diction['token']
recordimage_diction['related_collection'] = "admission_session_inscrit"
recordimage_diction['type_img'] = "user"
recordimage_diction['related_collection_recid'] = str(inscrit_id_data['_id'])
recordimage_diction['image_recid'] = diction['file_img_recid']
#print(" ### recordimage_diction stagaire = ", recordimage_diction)
local_status, local_message = mycommon.recordClassImage_v2(file_img, MYSY_GV.upload_folder, recordimage_diction)
if( local_status is False):
return local_status, local_message
return True, "L'image a été correctement enregistrée"
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
return False, "Impossible d'enregistrer l'image"
""" Recuperation de l'image d'un inscrit
Important : important : on prend le 'related_collection_recid' comme le '_id' de la collection de l'apprenant
"""
def Get_Inscrit_Admiss_Session_Recorded_Image_from_front(diction=None):
try:
# Dictionnaire des champs utilisables
field_list = ['token', 'inscrit_id']
incom_keys = diction.keys()
for val in incom_keys:
if val not in field_list and val.startswith('my_') is False:
mycommon.myprint(
str(inspect.stack()[0][3]) + " - Le champ '" + val + "' n'existe pas, requete annulée")
return False, " Impossible de récupérer les informations"
'''
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
On controle que les champs obligatoires sont presents dans la liste
'''
field_list_obligatoire = ['token', 'inscrit_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 la liste des arguments ")
return False, " Impossible de récupérer les informations"
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
# Verifier que l'apprenant est valide
is_inscrit_id_valide_count = MYSY_GV.dbname['admission_session_inscrit'].count_documents(
{'_id': ObjectId(diction['inscrit_id']),
'valide': '1',
'locked': '0',
'partner_owner_recid': str(my_partner['recid'])})
if (is_inscrit_id_valide_count != 1):
mycommon.myprint(str(inspect.stack()[0][3]) + " L'identifiant de l'inscrit est invalide ")
return False, " L'identifiant de l'inscrit est invalide "
inscrit_id_data = MYSY_GV.dbname['admission_session_inscrit'].find_one(
{'_id': ObjectId(diction['inscrit_id']),
'valide': '1',
'locked': '0',
'partner_owner_recid': str(my_partner['recid'])})
qery_images = {'locked': '0', 'valide': '1', 'related_collection': 'admission_session_inscrit',
'related_collection_recid': str(inscrit_id_data['_id'])}
RetObject = []
partner_images = {}
# Recuperation des image 'logo' et 'cachet' si le partenaire en a
for retVal in MYSY_GV.dbname['mysy_images'].find(qery_images):
if ('type_img' in retVal.keys()):
if (retVal['type_img'] == "user"):
partner_images['logo_img'] = retVal['img'].decode()
partner_images['logo_img_recid'] = retVal['recid']
RetObject.append(mycommon.JSONEncoder().encode(partner_images))
return True, RetObject
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
return False, " Impossible de recupérer l'image"
"""
Suppression d'un image d'un inscrit à une session d'admission
"""
def Delete_Inscrit_Admiss_Session_Image(diction=None):
try:
# Dictionnaire des champs utilisables
field_list = ['token', 'image_recid', ]
incom_keys = diction.keys()
'''
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
# field_list.
'''
for val in incom_keys:
if str(val).lower() not in str(field_list).lower():
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas accepté dans cette API")
return False, " Le champ '" + val + "' n'est pas accepté "
'''
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
On controle que les champs obligatoires sont presents dans la liste
'''
field_list_obligatoire = ['token', 'image_recid']
for val in field_list_obligatoire:
if str(val).lower() not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " La valeur '" + val + "' n'est pas presente dans la liste des arguments des champs")
return False, " La valeur '" + val + "' n'est pas presente dans la liste des arguments "
mydata = {}
mytoken = ""
# recuperation des paramettre
if ("token" in diction.keys()):
if diction['token']:
mytoken = diction['token']
image_recid = ""
if ("image_recid" in diction.keys()):
if diction['image_recid']:
image_recid = diction['image_recid']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
# " Lecture du fichier "
# print(" Lecture du fichier : " + saved_file + ". le token est :" + str(mytoken))
nb_line = 0
coll_name = MYSY_GV.dbname['mysy_images']
query_delete = {"recid": image_recid,}
ret_val = coll_name.delete_one({"recid": image_recid,}, )
#print(" ### recordClassImage_v2 :L'image a été correctement supprimée ")
return True, "L'image a été correctement supprimée"
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
return False, "Impossible de supprimer l'image "
"""
Recuperer les document fournis par un candidat dans le cadre d'un process d'inscription
"""
def Get_List_Candidat_Document(diction=None):
try:
# Dictionnaire des champs utilisables
field_list = ['token', 'inscrit_id', ]
incom_keys = diction.keys()
'''
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
# field_list.
'''
for val in incom_keys:
if str(val).lower() not in str(field_list).lower():
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas accepté dans cette API")
return False, " Le champ '" + val + "' n'est pas accepté "
'''
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
On controle que les champs obligatoires sont presents dans la liste
'''
field_list_obligatoire = ['token', 'inscrit_id', ]
for val in field_list_obligatoire:
if str(val).lower() not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " La valeur '" + val + "' n'est pas presente dans la liste des arguments des champs")
return False, " La valeur '" + val + "' n'est pas presente dans la liste des arguments "
mydata = {}
mytoken = ""
# recuperation des paramettre
if ("token" in diction.keys()):
if diction['token']:
mytoken = diction['token']
image_recid = ""
if ("image_recid" in diction.keys()):
if diction['image_recid']:
image_recid = diction['image_recid']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
qry_match = {"partner_owner_recid": str(my_partner['recid']), 'valide': '1', 'locked': '0'}
pipe_qry = ([
{"$addFields": {"admission_setup_document_id": {"$toString": "$_id"}}},
{'$match': qry_match},
{'$sort': {'_id': -1}},
{'$lookup': {
'from': 'download_files',
"let": {'admission_setup_document_id': "$admission_setup_document_id", 'partner_owner_recid': '$partner_owner_recid'},
'pipeline': [
{'$match':
{'$expr':
{'$and':
[
{'$eq': ["$admission_setup_document_id", '$$admission_setup_document_id']},
{'$eq': ["$valide", "1"]},
{'$eq': ["$partner_owner_recid", '$$partner_owner_recid']},
{'$eq': ["$object_owner_id", str(diction['inscrit_id'])]},
{'$eq': ["$object_owner_collection", 'admission_session_inscrit_document']},
]
}
}
},
],
'as': 'collection_download_files'
}
},
])
print(" #### Get_List_Candidat_Document pipe_qry = ", pipe_qry)
RetObject = []
val_tmp = 0
for New_retVal in MYSY_GV.dbname['admission_setup_document'].aggregate(pipe_qry):
#print(" ## New_retVal = ",New_retVal
if( "collection_download_files" in New_retVal.keys()):
for tmp_data in New_retVal['collection_download_files']:
if( "acceptance_status" not in tmp_data.keys()):
tmp_data['acceptance_status'] = ''
user = New_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()
print(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
return False, "Impossible de recuperer la liste des documents du candidat "
"""
Cette fonction definit la completude des pièce jointe jointe d'un candidat
% de pièce validé
"""
def Get_Pourcentage_Candidat_Document(diction=None):
try:
# Dictionnaire des champs utilisables
field_list = ['token', 'inscrit_id', ]
incom_keys = diction.keys()
'''
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
# field_list.
'''
for val in incom_keys:
if str(val).lower() not in str(field_list).lower():
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas accepté dans cette API")
return False, " Le champ '" + val + "' n'est pas accepté "
'''
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
On controle que les champs obligatoires sont presents dans la liste
'''
field_list_obligatoire = ['token', 'inscrit_id', ]
for val in field_list_obligatoire:
if str(val).lower() not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " La valeur '" + val + "' n'est pas presente dans la liste des arguments des champs")
return False, " La valeur '" + val + "' n'est pas presente dans la liste des arguments "
mydata = {}
mytoken = ""
# recuperation des paramettre
if ("token" in diction.keys()):
if diction['token']:
mytoken = diction['token']
image_recid = ""
if ("image_recid" in diction.keys()):
if diction['image_recid']:
image_recid = diction['image_recid']
local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
if (local_status is not True):
return local_status, my_partner
qry_match = {"partner_owner_recid": str(my_partner['recid']), 'valide': '1', 'locked': '0'}
pipe_qry = ([
{"$addFields": {"admission_setup_document_id": {"$toString": "$_id"}}},
{'$match': qry_match},
{'$sort': {'_id': -1}},
{'$lookup': {
'from': 'download_files',
"let": {'admission_setup_document_id': "$admission_setup_document_id", 'partner_owner_recid': '$partner_owner_recid'},
'pipeline': [
{'$match':
{'$expr':
{'$and':
[
{'$eq': ["$admission_setup_document_id", '$$admission_setup_document_id']},
{'$eq': ["$valide", "1"]},
{'$eq': ["$partner_owner_recid", '$$partner_owner_recid']},
{'$eq': ["$object_owner_id", str(diction['inscrit_id'])]},
{'$eq': ["$object_owner_collection", 'admission_session_inscrit_document']},
]
}
}
},
],
'as': 'collection_download_files'
}
},
])
print(" #### Get_List_Candidat_Document pipe_qry = ", pipe_qry)
RetObject = []
nb_document_accepted = 0
nb_document_rejected = 0
nb_document_send = 0
nb_document_no_status = 0
nb_document_not_send = 0
total_document_waited = 0
node_status = {}
RetObject = []
val_tmp = 0
for New_retVal in MYSY_GV.dbname['admission_setup_document'].aggregate(pipe_qry):
#print(" ## New_retVal = ",New_retVal
total_document_waited = total_document_waited + 1
if( "collection_download_files" in New_retVal.keys()):
for tmp_data in New_retVal['collection_download_files']:
if( "acceptance_status" not in tmp_data.keys()):
tmp_data['acceptance_status'] = ''
nb_document_no_status = nb_document_no_status + 1
nb_document_send = nb_document_send + 1
elif ( tmp_data['acceptance_status'] == "1"):
nb_document_accepted = nb_document_accepted + 1
nb_document_send = nb_document_send + 1
elif (tmp_data['acceptance_status'] == "-1"):
nb_document_rejected = nb_document_rejected + 1
nb_document_send = nb_document_send + 1
elif (tmp_data['acceptance_status'] == ""):
nb_document_no_status = nb_document_no_status + 1
nb_document_send = nb_document_send + 1
nb_document_not_send = total_document_waited - nb_document_send
pourcentage_accepted = ""
pourcentage_rejected = ""
pourcentage_send = ""
if( total_document_waited > 0 ):
pourcentage_accepted = round(float(nb_document_accepted) / float(total_document_waited), 2)
pourcentage_rejected = round(float(nb_document_rejected) / float(total_document_waited), 2)
pourcentage_send = round(float(nb_document_send) / float(total_document_waited), 2)
node_status['nb_document_accepted'] = str(nb_document_accepted)
node_status['nb_document_rejected'] = str(nb_document_rejected)
node_status['nb_document_send'] = str(nb_document_send)
node_status['nb_document_no_status'] = str(nb_document_no_status)
node_status['nb_document_not_send'] = str(nb_document_not_send)
node_status['total_document_waited'] = str(total_document_waited)
node_status['pourcentage_accepted'] = str(pourcentage_accepted)
node_status['pourcentage_rejected'] = str(pourcentage_rejected)
node_status['pourcentage_send'] = str(pourcentage_send)
RetObject.append(mycommon.JSONEncoder().encode(node_status))
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 documents du candidat "
"""
Pour usage interne
"""
def Internal_Get_Pourcentage_Candidat_Document(diction=None):
try:
# Dictionnaire des champs utilisables
field_list = ['partner_recid', 'inscrit_id', ]
incom_keys = diction.keys()
'''
# Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
# Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
# Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
# field_list.
'''
for val in incom_keys:
if str(val).lower() not in str(field_list).lower():
mycommon.myprint(
str(inspect.stack()[0][3]) + " Le champ '" + val + "' n'est pas accepté dans cette API")
return False, " Le champ '" + val + "' n'est pas accepté "
'''
Une fois qu'on a controlé que toutes les clés mise dans l'API sont correcte. etape precedente,
On controle que les champs obligatoires sont presents dans la liste
'''
field_list_obligatoire = ['partner_recid', 'inscrit_id', ]
for val in field_list_obligatoire:
if str(val).lower() not in diction:
mycommon.myprint(
str(inspect.stack()[0][3]) + " La valeur '" + val + "' n'est pas presente dans la liste des arguments des champs")
return False, " La valeur '" + val + "' n'est pas presente dans la liste des arguments "
mydata = {}
mytoken = ""
qry_match = {"partner_owner_recid": str(diction['partner_recid']), 'valide': '1', 'locked': '0'}
pipe_qry = ([
{"$addFields": {"admission_setup_document_id": {"$toString": "$_id"}}},
{'$match': qry_match},
{'$sort': {'_id': -1}},
{'$lookup': {
'from': 'download_files',
"let": {'admission_setup_document_id': "$admission_setup_document_id", 'partner_owner_recid': '$partner_owner_recid'},
'pipeline': [
{'$match':
{'$expr':
{'$and':
[
{'$eq': ["$admission_setup_document_id", '$$admission_setup_document_id']},
{'$eq': ["$valide", "1"]},
{'$eq': ["$partner_owner_recid", '$$partner_owner_recid']},
{'$eq': ["$object_owner_id", str(diction['inscrit_id'])]},
{'$eq': ["$object_owner_collection", 'admission_session_inscrit_document']},
]
}
}
},
],
'as': 'collection_download_files'
}
},
])
RetObject = []
nb_document_accepted = 0
nb_document_rejected = 0
nb_document_send = 0
nb_document_no_status = 0
nb_document_not_send = 0
total_document_waited = 0
node_status = {}
RetObject = []
val_tmp = 0
for New_retVal in MYSY_GV.dbname['admission_setup_document'].aggregate(pipe_qry):
#print(" ## New_retVal = ",New_retVal
total_document_waited = total_document_waited + 1
if( "collection_download_files" in New_retVal.keys()):
for tmp_data in New_retVal['collection_download_files']:
if( "acceptance_status" not in tmp_data.keys()):
tmp_data['acceptance_status'] = ''
nb_document_no_status = nb_document_no_status + 1
nb_document_send = nb_document_send + 1
elif ( tmp_data['acceptance_status'] == "1"):
nb_document_accepted = nb_document_accepted + 1
nb_document_send = nb_document_send + 1
elif (tmp_data['acceptance_status'] == "-1"):
nb_document_rejected = nb_document_rejected + 1
nb_document_send = nb_document_send + 1
elif (tmp_data['acceptance_status'] == ""):
nb_document_no_status = nb_document_no_status + 1
nb_document_send = nb_document_send + 1
nb_document_not_send = total_document_waited - nb_document_send
pourcentage_accepted = ""
pourcentage_rejected = ""
pourcentage_send = ""
if( total_document_waited > 0 ):
pourcentage_accepted = round(float(nb_document_accepted) / float(total_document_waited), 2)
pourcentage_rejected = round(float(nb_document_rejected) / float(total_document_waited), 2)
pourcentage_send = round(float(nb_document_send) / float(total_document_waited), 2)
node_status['nb_document_accepted'] = str(nb_document_accepted)
node_status['nb_document_rejected'] = str(nb_document_rejected)
node_status['nb_document_send'] = str(nb_document_send)
node_status['nb_document_no_status'] = str(nb_document_no_status)
node_status['nb_document_not_send'] = str(nb_document_not_send)
node_status['total_document_waited'] = str(total_document_waited)
node_status['pourcentage_accepted'] = str(pourcentage_accepted)
node_status['pourcentage_rejected'] = str(pourcentage_rejected)
node_status['pourcentage_send'] = str(pourcentage_send)
return True, node_status
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 documents du candidat "