"""
Ce fichier gere les sessions de 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
from datetime import timedelta


"""
Fonction de creation et mise à jour  d'une session de formation.

la clée est : 
- formation_session_id, 
- class_internal_url
"""
def Add_Update_SessionFormation(diction):
    try:

        '''
               # Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
               # Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
               # Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
               # field_list.
               '''
        field_list = ['token', 'date_debut', 'date_fin', 'nb_participant', 'formation_session_id', 'adresse',
                      'code_postal', 'ville', 'formateur', 'code_session',
                      'class_internal_url', 'session_status', 'date_debut_inscription', 'date_fin_inscription',
                      'attestation_certif',  "distantiel", "presentiel"]
        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 = ['token',  'formation_session_id',  'class_internal_url','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 liste ")
                return False, "Impossible de créer le stagiaire, Toutes les informations necessaires n'ont pas été fournies"

        mydata = {}
        query_key = {}

        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_token = diction['token']

        code_session = ""
        if ("code_session" in diction.keys()):
            if diction['code_session']:
                mydata['code_session'] = diction['code_session']
                query_key['code_session'] = diction['code_session']


        class_internal_url = ""
        if ("class_internal_url" in diction.keys()):
            if diction['class_internal_url']:
                mydata['class_internal_url'] = diction['class_internal_url']
                class_internal_url = diction['class_internal_url']


        partner_recid = mycommon.get_parnter_recid_from_token(my_token)
        if (partner_recid is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de créer la liste d'emargement ")
            return False, "Impossible de créer la liste d'emargement "

        formation_session_id = ""
        if ("formation_session_id" in diction.keys()):
            if diction['formation_session_id']:
                mydata['formation_session_id'] = diction['formation_session_id']

                session_id = diction['formation_session_id']


        if ("date_debut" in diction.keys()):
            if diction['date_debut']:
                mydata['date_debut'] = diction['date_debut']


        if ("date_fin" in diction.keys()):
            if diction['date_fin']:
                mydata['date_fin'] = diction['date_fin']


        if ("distantiel" in diction.keys()):
            if diction['distantiel']:
                mydata['distantiel'] = diction['distantiel']


        if ("presentiel" in diction.keys()):
            if diction['presentiel']:
                mydata['presentiel'] = diction['presentiel']

        if ("nb_participant" in diction.keys()):
            if diction['nb_participant']:
                mydata['nb_participant'] = diction['nb_participant']

        if ("adresse" in diction.keys()):
            if diction['adresse']:
                mydata['adresse'] = diction['adresse']


        if ("code_postal" in diction.keys()):
            if diction['code_postal']:
                ## Verifier si le CP n'est composé que de "0", au quel cas il s'agit d'une formation en ligne.
                local_cp = str(diction['code_postal']).replace("0","").strip()

                if( local_cp == ""):
                    mydata['code_postal'] = "0"

                else:
                    mydata['code_postal'] = diction['code_postal']



        if ("ville" in diction.keys()):
            if diction['ville']:
                mydata['ville'] = diction['ville']

        if ("attestation_certif" in diction.keys()):
            if diction['attestation_certif']:
                mydata['attestation_certif'] = diction['attestation_certif']


        if ("session_status" in diction.keys()):
            if diction['session_status']:
                mydata['session_status'] = diction['session_status']

        if ("date_debut_inscription" in diction.keys()):
            if diction['date_debut_inscription']:
                mydata['date_debut_inscription'] = diction['date_debut_inscription']

        if ("date_fin_inscription" in diction.keys()):
            if diction['date_fin_inscription']:
                mydata['date_fin_inscription'] = diction['date_fin_inscription']

        if ("formateur" in diction.keys()):
            if diction['formateur']:
                mydata['formateur'] = diction['formateur']


        mydata['date_update'] = str(datetime.now())
        mydata['valide'] = "1"

        # Controle de cohérence sur les dates
        local_status = mycommon.CheckisDate(str(diction['date_debut'])[0:10])
        if (local_status is False):
            mycommon.myprint(
                str(inspect.stack()[0][
                        3]) + " - Impossible de créer/mettre à jour la session de formation. La date de debut n'est pas au format jj/mm/aaaa ")

            return False, " - Impossible de créer/mettre à jour la session de formation. La date de debut n'est pas au format jj/mm/aaaa "

        local_status = mycommon.CheckisDate(str(diction['date_fin'])[0:10])
        if (local_status is False):
            mycommon.myprint(
                str(inspect.stack()[0][
                        3]) + " - Impossible de créer/mettre à jour la session de formation. La date de fin n'est pas au format jj/mm/aaaa ")

            return False, " - Impossible de créer/mettre à jour la session de formation. La date de fin n'est pas au format jj/mm/aaaa "

        local_status = mycommon.CheckisDate(str(diction['date_debut_inscription'])[0:10])
        if (local_status is False):
            mycommon.myprint(
                str(inspect.stack()[0][
                        3]) + " - Impossible de créer/mettre à jour la session de formation. La  date_debut_inscription  n'est pas au format jj/mm/aaaa ")

            return False, " - Impossible de créer/mettre à jour la session de formation. La date_debut_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]) + " - Impossible de créer/mettre à jour la session de formation. La date_fin_inscription  n'est pas au format jj/mm/aaaa ")

            return False, " - Impossible de créer/mettre à jour la session de formation. La date_fin_inscription  n'est pas au format jj/mm/aaaa "



        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]) + " - Impossible de créer/mettre à jour la session de formation : La date debut " + str(
                    diction['date_debut']) +
                " est posterieure à la date de fin " + str(diction['date_fin']) )

            return False, " Impossible de créer la session de formation : La date debut " + str(diction['date_debut']) + \
                   " est posterieure à la date de fin " + str(diction['date_fin']) + "  "


        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]) + " - Impossible de créer/mettre à jour la session de formation : La date date_debut_inscription " + str(
                    diction['date_debut_inscription']) +
                " est posterieure à la date de date_fin_inscription  " + str(diction['date_fin_inscription']) )

            return False, " Impossible de créer /mettre à jour la session de formation : La  date_debut_inscription " + str(diction['date_debut_inscription']) + \
                   " est posterieure à la date_fin_inscription  " + str(diction['date_fin_inscription']) + "  "


        mytoday = datetime.today().strftime("%d/%m/%Y")
        if (datetime.strptime(str(diction['date_debut'])[0:10], '%d/%m/%Y') < datetime.strptime(str(mytoday).strip(), '%d/%m/%Y')) :
            mycommon.myprint(
                str(inspect.stack()[0][
                        3]) + " - Impossible de créer/mettre à jour la session de formation : La date de debut de sessions " + str(
                    diction['date_debut']) +" est antirieure à la date du jour  ")

            return False, "  - Impossible de créer/mettre à jour la session de formation : La date de debut de sessions " + str(
                    diction['date_debut']) +" est antirieure à la date du jour   "


        # Fin Controle de cohérence sur les dates


        print(" ### query_key = ", query_key)
        coll_name = MYSY_GV.dbname['session_formation']
        ret_val = coll_name.find_one_and_update(
            query_key,
            {"$set": mydata},
            upsert=True,
            return_document=ReturnDocument.AFTER
        )

        if (ret_val['_id'] is False):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " Impossible d'ajouter/mettre à jour la session '"+str(diction['code_session'])+"' ")
            return False, "Impossible d'ajouter/mettre à jour la session '"+str(diction['code_session'])+"' "



        return True, " La session de formation  à 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 de créer la session de formation"


"""
Fonction de recuperation d'une session de formation
"""

def GetSessionFormation(diction):
    try:

        field_list = ['token', 'class_internal_url', 'formation_session_id', ]
        incom_keys = diction.keys()
        for val in incom_keys:
            if val not in field_list:
                mycommon.myprint(str(inspect.stack()[0][
                                         3]) + " -  Le champ  '" + val + "' n'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', 'formation_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']

        formation_session_id = ""
        if ("formation_session_id" in diction.keys()):
            if diction['formation_session_id']:
                formation_session_id = diction['formation_session_id']

        coll_session = MYSY_GV.dbname['session_formation']
        myquery = {}
        myquery['formation_session_id'] = formation_session_id
        myquery['class_internal_url'] = class_internal_url


        print(" ##### myquery = "+str(myquery))
        RetObject = []

        for retval in coll_session.find(myquery):
            #print(" ##### retval = " + str(retval))
            RetObject.append(mycommon.JSONEncoder().encode(retval))

        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 session de formation"


"""
Cette fonction recupere la liste de toutes les sessions de formation actives et valide
d'une formation données. 
"""
def GetActiveSessionFormation_List(diction):
    try:

        field_list = ['class_internal_url']
        incom_keys = diction.keys()
        for val in incom_keys:
            if val not in field_list:
                mycommon.myprint(str(inspect.stack()[0][
                                         3]) + " -  Le champ  '" + val + "' n'est pas autorisé, Creation partenaire annulée")
                return False, " Impossible de recuperer la liste des session de formation"

        """
        Verification de la liste des champs obligatoires
        """
        field_list_obligatoire = [ 'class_internal_url', ]
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " -  : La valeur '" + val + "' n'est pas presente dans liste ")
                return False, "Impossible de recuperer la liste des session de formation"

        # Recuperation du recid du partner
        mydata = {}

        class_internal_url = ""
        if ("class_internal_url" in diction.keys()):
            if diction['class_internal_url']:
                class_internal_url = diction['class_internal_url']

        coll_session = MYSY_GV.dbname['session_formation']
        myquery = {}
        myquery['class_internal_url'] = class_internal_url
        myquery['valide'] = "1"
        myquery['session_status'] = "true"
        RetObject = []

        print(" ### myquery = ", myquery)
        for retval in coll_session.find(myquery):

            local_tmp = retval
            ## Verification des conditions supplementaires :
            # en realité c'est parce que c'est chaud de le faire avec pymongo
            tmp_debut_inscritp = str(local_tmp['date_debut_inscription']).strip().split(" ")
            tmp_fin_inscritp = str(local_tmp['date_fin_inscription']).strip().split(" ")

            debut_inscr = datetime.strptime(str(tmp_debut_inscritp[0]).strip(), '%d/%m/%Y')
            fin_inscr = datetime.strptime(str(tmp_fin_inscritp[0]).strip(), '%d/%m/%Y')

            #print(" #### date_debut_inscription = ", debut_inscr,  " date_fin_inscription = ", fin_inscr, " NOW = ",datetime.now())
            if(debut_inscr <= datetime.now() and  fin_inscr >= datetime.now()):
                RetObject.append(mycommon.JSONEncoder().encode(retval))






        print("####RetObject = "+str(RetObject))
        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 sessions de formation valides et actives."

"""
Cette fonction recuperer la liste des toutes les sessions
de formation valides pour une formation données.
Qu'elles soient cloturées ou pas."""
def GetAllValideSessionFormation_List(diction):
    try:

        field_list = ['class_internal_url']
        incom_keys = diction.keys()
        for val in incom_keys:
            if val not in field_list:
                mycommon.myprint(str(inspect.stack()[0][
                                         3]) + " -  Le champ  '" + val + "' n'est pas autorisé, Creation partenaire annulée")
                return False, " Impossible de recuperer la liste des session de formation"

        """
        Verification de la liste des champs obligatoires
        """
        field_list_obligatoire = ['class_internal_url', ]
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " -  : La valeur '" + val + "' n'est pas presente dans liste ")
                return False, "Impossible de recuperer la liste des session de formation"

        # Recuperation du recid du partner
        mydata = {}

        class_internal_url = ""
        if ("class_internal_url" in diction.keys()):
            if diction['class_internal_url']:
                class_internal_url = diction['class_internal_url']

        coll_session = MYSY_GV.dbname['session_formation']
        myquery = {}
        myquery['class_internal_url'] = class_internal_url
        myquery['valide'] = "1"

        #print(" ##### myquery = "+str(myquery))
        RetObject = []

        for retval in coll_session.find(myquery):
            #print(" ##### retval = " + str(retval))
            RetObject.append(mycommon.JSONEncoder().encode(retval))

        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 sessions de formation valides et actives."


"""
Cette fonction crée les sessions de formation en mass
par exemple avec l'import d'un fichier csv
"""
def Add_Update_SessionFormation_mass(file=None, Folder=None, diction=None):
    try:
        '''
               # Verification que les champs reçus dans l'API sont bien dans la liste des champs autorisés
               # Cela evite le cas ou une entité tierce ajouter les valeurs inconnu dans l'API
               # Ici on doit mettre tous les champs possible (obligatoire ou non) de la BDD dans la liste
               # field_list.
               '''
        field_list = ['token', 'class_internal_url']
        incom_keys = diction.keys()
        for val in incom_keys:
            if val not in field_list:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + "  Le champ  '" + val + "' n'existe pas, Creation session annulée")
                return False, " Le champ  '" + val + "' n'existe pas, Creation session annulée "

        '''
        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', 'class_internal_url']

        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
                return False, " La valeur '" + val + "' n'est pas presente dans liste"

        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_token = diction['token']

        class_internal_url = ""
        if ("class_internal_url" in diction.keys()):
            if diction['class_internal_url']:
                class_internal_url = diction['class_internal_url']

        if (len(str(class_internal_url).strip()) <= 0):
            mycommon.myprint(
                str(inspect.stack()[0][
                        3]) + " Le code de la formation est vide : Impossible d'importer la liste des sessions ")
            return False, "Le code de la formation est vide. Impossible d'importer la liste des sessions"

        partner_recid = mycommon.get_parnter_recid_from_token(my_token)
        if (partner_recid is False):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - partner_recid KO : Impossible d'importer la liste des sessions ")
            return False, "les information de connexion sont incorrectes. Impossible d'importer la liste des sessions"

        status, saved_file = mycommon.Upload_Save_CSV_File(file, Folder)
        if (status == False):
            return False, "Impossible d'importer la liste des sessions, le nom du fichier est incorrect "

        # " Lecture du fichier "
        # print(" Lecture du fichier : "+saved_file)
        nb_line = 0

        df = pd.read_csv(saved_file, encoding='utf8', on_bad_lines='skip', sep=';')

        # Dictionnaire des champs utilisables
        '''
        # Verification que les noms des colonne sont bien corrects"
        '''
        field_list = ['date_debut', 'date_fin', 'nb_participant', 'adresse', 'code_postal', 'ville',
                      'session_status', 'date_debut_inscription', 'date_fin_inscription', 'attestation', 'formateur',
                      'code_session', "distantiel", "presentiel"]

        # Controle du nombre de lignes dans le fichier.
        total_rows = len(df)
        if (total_rows > MYSY_GV.MAX_PARTICIPANT_BY_CSV):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " Le fichier comporte plus de " + str(
                    MYSY_GV.MAX_PARTICIPANT_BY_CSV) + " lignes.")
            return False, " Le fichier comporte plus de " + str(MYSY_GV.MAX_PARTICIPANT_BY_CSV) + " lignes."

        # print(df.columns)
        for val in df.columns:
            if str(val).lower() not in field_list:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " : entete du fichier csv. '" + val + "' n'est pas acceptée")
                return False, " Entete du fichier csv. '" + val + "' n'est pas acceptée"


        # Verification des champs obligatoires dans le fichier
        field_list_obligatoire_file = ['date_debut', 'date_fin', 'session_status',  'code_session']

        for val in field_list_obligatoire_file:
            if val not in df.columns:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " : Le champ '" + val + "' n'est pas présent dans le fichier. Il est obligatoire")
                return False, " Le champ '" + val + "' n'est pas présent dans le fichier. Il est obligatoire "


        # Recuperation des info de la formation.
        formation_data = MYSY_GV.dbname['myclass'].find_one({'internal_url': str(class_internal_url)})
        if (formation_data is None):
            mycommon.myprint(
                str(inspect.stack()[0][
                        3]) + " La session de formation n'existe pas : Impossible d'importer la liste des participants ")
            return False, "la session de formation n'existe pas. Impossible d'importer la liste des participants"

        x = range(0, total_rows)
        for n in x:
            mydata = {}


            mydata['date_debut'] = str(df['date_debut'].values[n]).strip().split(" ")[0]
            local_status = mycommon.CheckisDate(mydata['date_debut'])
            if(local_status is False ):
                mycommon.myprint(
                    str(inspect.stack()[0][
                            3]) + " - Impossible de créer/mettre à jour la session de formation à ligne "+str(n)+"."
                              "La date debut n'est pas au format jj/mm/aaaa ")

                return False, " - Impossible de créer/mettre à jour la session de formation à ligne "+str(n)+". La date debut n'est pas au format jj/mm/aaaa "

            mydata['date_fin'] = str(df['date_fin'].values[n]).strip().split(" ")[0]
            local_status = mycommon.CheckisDate(mydata['date_fin'])
            if (local_status is False):
                mycommon.myprint(
                    str(inspect.stack()[0][
                            3]) + " - Impossible de créer/mettre à jour la session de formation à ligne " + str(n) + "."
                                                                                                                     "La date date_fin n'est pas au format jj/mm/aaaa ")

                return False, " - Impossible de créer/mettre à jour la session de formation à ligne " + str(
                    n) + ". La date fin n'est pas au format jj/mm/aaaa "


            ## Verification de la cohérence des dates. Date_du doit <= Date_au
            if (datetime.strptime(str(mydata['date_debut']).strip(), '%d/%m/%Y') > datetime.strptime(
                    str(mydata['date_fin']).strip(), '%d/%m/%Y')):
                mycommon.myprint(
                    str(inspect.stack()[0][
                            3]) + " - Impossible de créer la session de formation : La date debut " + str(mydata['date_debut']) +
                    " est posterieure à la date de fin " + str(mydata['date_fin']) + " pour la ligne  "+str(n)+" ")

                return False, " Impossible de créer la session de formation : La date debut " + str(mydata['date_debut']) +\
                       " est posterieure à la date de fin " + str(mydata['date_fin']) + " pour la ligne  "+str(n)+" "


            local_nb_participants = "0"
            if ("nb_participant" in df.keys()):
                if (str(df['nb_participant'].values[n])):
                    local_nb_participants = str(df['nb_participant'].values[n]).strip()

            local_status, new_participants = mycommon.IsInt(local_nb_participants)
            if (local_status is False):
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " Le champs 'nb_participant' de ligne " + str(n) + " est incorrecte.")
                return False, " Le champs nb_participant de ligne " + str(n) + " est incorrecte. "

            mydata['nb_participant'] = str(new_participants)

            local_code_session = ""
            if ("code_session" in df.keys()):
                if (str(df['code_session'].values[n])):
                    local_code_session = str(df['code_session'].values[n]).strip()
            mydata['code_session'] = local_code_session

            local_adresse = ""
            if ("adresse" in df.keys()):
                if (str(df['adresse'].values[n])):
                    local_adresse = str(df['adresse'].values[n]).strip()
            mydata['adresse'] = local_adresse



            local_code_postal = ""
            if ("code_postal" in df.keys()):
                if (str(df['code_postal'].values[n])):
                    local_code_postal = str(df['code_postal'].values[n]).strip()
            mydata['code_postal'] = local_code_postal

            distantiel = ""
            if ("distantiel" in df.keys()):
                if (str(df['distantiel'].values[n])):
                    distanciel = str(df['distantiel'].values[n]).strip()
            mydata['distantiel'] = distanciel

            presentiel = ""
            if ("presentiel" in df.keys()):
                if (str(df['presentiel'].values[n])):
                    presentiel = str(df['presentiel'].values[n]).strip()
            mydata['presentiel'] = presentiel

            #mydata['code_postal'] = str(df['code_postal'].values[n]).strip()

            local_ville = ""
            if ("ville" in df.keys()):
                if (str(df['ville'].values[n])):
                    local_ville = str(df['ville'].values[n]).strip()
            mydata['ville'] = local_ville

            #mydata['ville'] = str(df['ville'].values[n]).strip()

            local_attestation_certif = ""
            if ("attestation" in df.keys()):
                if (str(df['attestation'].values[n])):
                    local_attestation_certif = str(df['attestation'].values[n]).strip()
            mydata['attestation_certif'] = local_attestation_certif

            #mydata['attestation_certif'] = str(df['attestation'].values[n]).strip()

            local_formateur = ""
            if ("formateur" in df.keys()):
                if (str(df['formateur'].values[n])):
                    local_formateur = str(df['formateur'].values[n]).strip()
            mydata['formateur'] = local_formateur


            local_session = str(df['session_status'].values[n]).strip()

            if( str(local_session) != "0" and  str(local_session) != "1" and  str(local_session) != "2"):
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " Le champs 'session_status' de ligne " + str(n) + " est incorrecte. Les valeurs acceptées sont 0,1,2")
                return False, " Le champs nb_participant de ligne " + str(n) + " est incorrecte. Les valeurs acceptées sont 0,1,2"

            if( str(local_session) == "1"):
                mydata['session_status'] = str("true")


            mydata['date_debut_inscription'] = str(df['date_debut_inscription'].values[n]).strip().split(" ")[0]
            local_status = mycommon.CheckisDate(mydata['date_debut_inscription'])
            if (local_status is False):
                mycommon.myprint(
                    str(inspect.stack()[0][
                            3]) + " - Impossible de créer/mettre à jour la session de formation à ligne " + str(n) + "."
                                                                                                                     "La  date_debut_inscription n'est pas au format jj/mm/aaaa ")

                return False, " - Impossible de créer/mettre à jour la session de formation à ligne " + str(
                    n) + ". La date_debut_inscription n'est pas au format jj/mm/aaaa "


            mydata['date_fin_inscription'] = str(df['date_fin_inscription'].values[n]).strip().split(" ")[0]
            local_status = mycommon.CheckisDate(mydata['date_fin_inscription'])
            if (local_status is False):
                mycommon.myprint(
                    str(inspect.stack()[0][
                            3]) + " - Impossible de créer/mettre à jour la session de formation à ligne " + str(n) + "."
                                                                                                                     "La date_fin_inscription n'est pas au format jj/mm/aaaa ")

                return False, " - Impossible de créer/mettre à jour la session de formation à ligne " + str(
                    n) + ". La date_fin_inscription n'est pas au format jj/mm/aaaa "

            ## Verification de la cohérence des dates. Date_du doit <= Date_au
            if (datetime.strptime(str(mydata['date_debut_inscription']).strip(), '%d/%m/%Y') > datetime.strptime(
                    str(mydata['date_fin_inscription']).strip(), '%d/%m/%Y')):
                mycommon.myprint(
                    str(inspect.stack()[0][
                            3]) + " - Impossible de créer la session de formation : La date debut des inscriptions " + str(
                        mydata['date_debut_inscription']) +
                    " est posterieure à la date de fin des inscriptions " + str(mydata['date_fin_inscription']) + " pour la ligne  "+str(n)+" ")

                return False, " Impossible de créer la session de formation : La date debut des inscriptions " + str(
                    mydata['date_debut_inscription']) + \
                       " est posterieure à la date de fin des inscriptions" + str(mydata['date_fin_inscription']) + " pour la ligne  "+str(n)+" "

            mydata['token'] = str(my_token)
            mydata['class_internal_url'] = str(class_internal_url)

            print(" ### mydata ", mydata)

            diction_for_session_id = {}
            diction_for_session_id['date_du'] = str(mydata['date_debut']).split(" ")[0]
            diction_for_session_id['date_au'] = str(mydata['date_fin']).split(" ")[0]
            diction_for_session_id['code_postal'] = str(mydata['code_postal'] )
            diction_for_session_id['adresse'] = str(mydata['adresse'])



            mydata['formation_session_id'] = str(mydata['code_session'])

            clean_dict = {k: mydata[k] for k in mydata if (str(mydata[k]) != "nan")}

            print("####  Add_Update_SessionFormation_mass : clean_dict ", clean_dict)
            status, retval = Add_Update_SessionFormation(clean_dict)

            if (status is False):
                return status, retval


        print(str(total_rows) + " sessions ont été inserées")

        return True, str(total_rows) + "  sessions ont été inserées / Mises à jour"

    except Exception as e:
        exc_type, exc_obj, exc_tb = sys.exc_info()
        mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - ERRORRRR AT Line : " + str(exc_tb.tb_lineno))
        return False, "Impossible d'importer les sessions de formation  en masse "