import pymongo
import pysftp
import zeep
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
from math import isnan
import GlobalVariable as MYSY_GV
import ela_index_bdd_classes as eibdd
import email_mgt as email_mgt
import socket
import smtplib
import re
import requests
# Connexion mariadb sur serveur
import mariadb
import hashlib
import bcrypt
from pymongo import ReturnDocument
import paramiko
from Levenshtein import distance as lev
import class_mgt as class_mgt
import Session_Formation as Session_Formation
from unidecode import unidecode
"""
Test connexion SQL sur localhost Phpmyadmin
"""
def test_connexion_php_myadmin():
    try:
        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()

        conn.close()
        return  True, " Connexion OK"

    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 se connecter"





"""
Cette fonction créer un utilisateur (compte principale)  lms mysy, donc dans chamilo
"""
def Create_MySy_LMS_User(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', 'lastname', 'firstname', 'email', 'password', 'locked', 'official_code', 'username']

        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 autorisé", False

        '''
        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', 'lastname', 'firstname', 'email', 'password', 'locked', 'official_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 liste ")
                return False, " Toutes les informations obligatoire n'ont pas été fournies", False

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_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

        partner_recid = str(my_partner['recid'])



        lastname = ""
        if ("lastname" in diction.keys()):
            if diction['lastname']:
               local_status,  lastname = mycommon.RemoveAllNonAlphaNumeric( diction['lastname'])

        firstname = ""
        if ("firstname" in diction.keys()):
            if diction['firstname']:
                local_status, firstname = mycommon.RemoveAllNonAlphaNumeric( diction['firstname'] )

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

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

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

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

        username = ""
        if ("username" in diction.keys()):
            if diction['username']:
                local_status, username = mycommon.RemoveAllNonAlphaNumeric( diction['username'])

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du partenaire"

        nom_partner = ""
        if ("nom" not in my_partner.keys()):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le nom du partenaire est vide ")
            return False, str(inspect.stack()[0][3]) + "  -  Le nom du partenaire est vide "


        nom_partner = mycommon.remove_non_ascii(str(my_partner['nom']) )

        local_status, nom_partner = mycommon.local_Remove_Ponct_Special_Caractere( nom_partner )
        if (local_status is False ):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le nom du partenaire : local_Remove_Ponct_Special_Caractere ")
            return False, str(inspect.stack()[0][3]) + "  -  Le nom du partenaire : local_Remove_Ponct_Special_Caractere "

        suffix_nom_partner = str(nom_partner)[0:3]

        username = str(str(username)+"_"+str(suffix_nom_partner)).lower()
        local_status, username = mycommon.RemoveAllNonAlphaNumeric(unidecode(username))
        if( local_status is False ):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - erreur  : RemoveAllNonAlphaNumeric ")
            return False, str(
                inspect.stack()[0][3]) + "  -  erreur : RemoveAllNonAlphaNumeric "

        #print(" ### username = ",username)
        registration_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")


        # Rcuperation de la sequence de l'objet "lms_user_id" dans la collection : "mysy_sequence"
        retval = MYSY_GV.dbname['mysy_sequence'].find_one({'related_mysy_object':'lms_user_id', 'valide':'1'})


        mypasswd  = password.encode('UTF-8')

        salt = bcrypt.gensalt()
        hashed_pwd = bcrypt.hashpw(mypasswd, salt)


        if (type(salt) is bytes):
            salt = salt.decode("UTF-8")
            hashed_pwd = hashed_pwd.decode("UTF-8")



        if (retval is None or "current_val" not in retval.keys()):
            mycommon.myprint(" Impossible de récupérer la sequence 'mysy_sequence' ")
            return False, "Impossible de récupérer la sequence 'mysy_sequence'",False

        new_lms_user_id = str(retval['prefixe'])+str(retval['current_val'])
        local_status, local_val = mycommon.IsInt(new_lms_user_id)
        if( local_status is False):
            mycommon.myprint(" Impossible de generer l'ID du user LMS. La valeur actuelle est ", new_lms_user_id)
            return False, " Impossible de generer l'ID du user LMS", False

        current_seq_value = str(retval['current_val'])

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()
        """
        # retrieving information
        cur.execute("SELECT username, email_canonical FROM user WHERE id=?", (2,))

        for username, email_canonical in cur:
            print(f"username: {username},  email_canonical : {email_canonical}")
        """
        # Verification d'abord si le compte exite.
        query_compte_exist = " Select count(*), user_id From  user WHERE username = '"+username+"' "
        print(" ### query_compte_exist = ", query_compte_exist)
        query_compte_exist_exec = cur.execute(query_compte_exist)

        query_compte_exist_exec = ""
        query_compte_exist_exec_val = "0"
        for query_compte_exist_exec in cur:
            query_compte_exist_exec_val = query_compte_exist_exec[0]
            if (int(mycommon.tryInt(query_compte_exist_exec_val)) > 0):
                new_lms_user_id = query_compte_exist_exec[1]
        conn.commit()


        if( int(mycommon.tryInt(query_compte_exist_exec_val)) > 0  ):
            # Le compte existe, il faut donc faire une mise à jour
            my_query = "UPDATE user SET salt = '" + str(salt) + "', credentials_expired='0', " \
                                                                "updated_at='" + str(registration_date) + " ',  " \
                                                                                                          "password = '" + str(
                hashed_pwd) + "', " \
                              "enabled='1', " \
                              "expired='0',  " \
                              "mysy_recid='"+str(my_partner['_id'])+"',  " \
                                                                    "mysy_partner_owner_recid='" + str(
                my_partner['recid']) + "',  " \
                                       "locked = '0', " \
                              "auth_source = 'platform'," \
                              "roles = 'a:0:{}', " \
                              "language = 'french'," \
                              "username_canonical = '" + username + "', " \
                                                                    " email_canonical = '" + email + "', " \
                                                                                                     "email = '" + email + "'," \
                                                                                                                           " official_code	= '" + official_code + "', " \
                                                                                                                                                                     "active = '1' WHERE  username='" + str(
                email) + "' ;"
        else:
            # Le compte n'existe pas, il faut le créer


            # insert information
            my_query = "INSERT INTO user SET id='"+str(new_lms_user_id)+"' ,  " \
                                                                        "user_id='"+str(new_lms_user_id)+"' , " \
                                                                                                         "lastname = '"+lastname+"', " \
                                                                                                         "firstname = '"+firstname+"',  " \
                                                                                                         "username = '"+username+"', " \
                                                                                                         "mysy_recid='" +str(my_partner['_id']) + "',  " \
                                                                                                          "mysy_partner_owner_recid='" + str(my_partner['recid']) + "',  " \
                                       "salt = '"+str(salt)+"'," \
                                                                                                         " registration_date = '"+registration_date+"'," \
                                                                                                         " credentials_expired='0', " \
                                                                                                         "enabled='1', " \
                                                                                                         "expired='0',  " \
                                                                                                                                                    "created_at='" + str( registration_date) + "'," \
                                                                                                                                                                                               "  updated_at='" + str( registration_date) + "', " \
                                                                                                                                                                                                                                            " status = '1', " \
                                                                                                         "password = '"+str(hashed_pwd)+"', " \
                                                                                                         "locked = '0', " \
                                                                                                         "username_canonical = '"+username+"', " \
                                                                                                         " email_canonical = '"+email+"', " \
                                                                                                         "email = '"+email+"'," \
                                                                                                         " official_code	= '"+official_code+"', " \
                                                                                                         "creator_id  = '1', " \
                                                                                                         "auth_source = 'platform'," \
                                                                                                         "roles = 'a:0:{}', " \
                                                                                                         "language = 'french'," \
                                                                                                         "active = '1';"

        try:
            print(" ### my_query aaa = ", my_query)
            #cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query)
        except mariadb.Error as e:
            #print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'utilisateur LMS "+str({e}))
            return False, "Impossible de créer l'utilisateur LMS "+str({e}), False

        conn.commit()
        #print(f"Last Inserted ID: {cur.lastrowid}")

        """ 
        ## Si l'insertion dans la table user s'est bien passé, alors on ajoute le user_id à la table 'access_url_rel_user'
        Cette table permet faire la recherche et d'envoyer des email dans le LMS.
        Ainsi un utilisateur saisira juste les 3 première lettre du 'send to'
        /!\ On l'ajout d'abord par defaut pour le l'url racine.
        /!\ On va l'ajouter une 2ieme fois si le compte partenaire necessite la creation d'un nouvel url.
        """
        my_query_access_url_rel_user = "INSERT INTO access_url_rel_user SET access_url_id='1' ,  user_id='" + str(
            new_lms_user_id) + "'  "
        print(" ### my_query_access_url_rel_user = ", my_query_access_url_rel_user)
        try:

            #cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query_access_url_rel_user)
        except mariadb.Error as e:
            #print(f"Error: {e}")
            mycommon.myprint(str(inspect.stack()[0][3]) + " WARNING - impossible d'ajouter le user '"+str(
            new_lms_user_id)+"'  à la table access_url_rel_user pour la recheche et l'envoi des email")

        conn.commit()


        """"
        Creaion des valeur 'nb_formation' et pack dans la table 'extra_field_values' 
        """
        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du partenaire"


        new_dicton = {}
        new_dicton['token'] = my_token
        new_dicton['lms_user_id'] = str(new_lms_user_id)
        new_dicton['mysy_pack'] = my_partner['pack_service']
        new_dicton['mysy_nb_formation'] =  my_partner['nb_formation']

        local_status, local_message, local_value = Update_Pack_MySy_LMS_User(new_dicton)
        if( local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - WARNING : impossible de créer les varible MySy dans le LMS")

        lastrowid = cur.lastrowid


        """
        A present que le compte est créé, on va créer l'url / virtualhost et affecter l'utilisateur à ce virtualHost
        """
        virutal_host_id = ""
        virutal_host_url = ""
        local_data = {}
        local_data['token'] = my_token
        local_data['lms_username'] = username
        local_status, local_message, local_virtualhost_id, local_virtualhost_full_url = LMS_Create_VirtualHost(local_data)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - WARNING : impossible de créer le virtualHost dans le LMS ")
        else:
            """ 
                   /!\ On va l'ajouter une 2ieme fois si le compte partenaire necessite la creation d'un nouvel url.
                   /!\ : on ajoute aussi le user admin qui a comme user_id = 1
                   """
            virutal_host_id = local_virtualhost_id
            virutal_host_url = local_virtualhost_full_url
            my_query_access_url_rel_user = "INSERT INTO access_url_rel_user SET access_url_id='"+ str(virutal_host_id)+"' ,  user_id='" + str(new_lms_user_id) + "'  "
            my_query_access_url_rel_user_admin = "INSERT INTO access_url_rel_user SET access_url_id='" + str(
                virutal_host_id) + "' ,  user_id='1'  "

            print(" ### my_query_access_url_rel_user = ", my_query_access_url_rel_user)
            print(" ### my_query_access_url_rel_user_admin = ", my_query_access_url_rel_user)
            try:

                # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
                cur.execute(my_query_access_url_rel_user)
                cur.execute(my_query_access_url_rel_user_admin)
            except mariadb.Error as e:
                # print(f"Error: {e}")
                mycommon.myprint(str(inspect.stack()[0][3]) + " WARNING - impossible d'ajouter le user '" + str(
                    new_lms_user_id) + "'  à la table access_url_rel_user pour la recheche et l'envoi des email")

            conn.commit()

            """
            Envoie de l'email contenant les information de connection à la plateforme 
            d'hébergement
            """
            local_mydata2 = {}
            local_mydata2['token'] = my_token
            local_status2, local_message2 = email_mgt.Email_Part_Espace_Hosting(local_mydata2)
            if( local_status2 is False):
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - WARNING : Impossible d'envoyer les identifiants de connexion à la plateforme d'hébergement par email ")


        conn.close()

        # Crementation de la sequence de l'objet "lms_user_id" dans la collection : "mysy_sequence"

        print(" ### current_seq_value = ", current_seq_value)
        new_sequence_value = int(mycommon.tryInt(current_seq_value))+1

        #print(" ### New_current_seq_value = ", current_seq_value)

        mydata = {'current_val':new_sequence_value}
        ret_val2 = MYSY_GV.dbname['mysy_sequence'].find_one_and_update({'related_mysy_object':'lms_user_id', 'valide':'1'},
                                                        {"$set": mydata},
                                                        return_document=ReturnDocument.AFTER,
                                                                       upsert= False,
                                                        )


        return  True, " Creation du compte LMS OK. l'id = "+str(new_lms_user_id), str(new_lms_user_id)

    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 le compte LMS", False


"""
Cette fonction permet de mofifier le mot de passe de l'utilisateur
"""

def Update_Passwd_MySy_LMS_User(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', 'new_password', 'lms_user_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 autorisé", False

        '''
        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',  'new_password', 'lms_user_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, " Toutes les informations obligatoire n'ont pas été fournies", False

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_token = diction['token']

        partner_recid = ""
        # Verification de la validité du token/mail dans le cas des user en mode connecté
        if (len(str(my_token)) > 0):
            retval = mycommon.check_partner_token_validity("", my_token)

            if retval is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide")
                return False, " Impossible de mettre à jour le compte LMS", False

            # Recuperation du recid de l'utilisateur
            partner_recid = mycommon.get_parnter_recid_from_token(my_token)
            if partner_recid is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire")
                return False, " Impossible de récupérer le token du partenaire", False

        if (len(str(my_token)) <= 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le token est vide")
            return False, " Impossible de mettre à jour le compte LMS", False



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


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



        updated_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        mypasswd = newpassword.encode('UTF-8')

        salt = bcrypt.gensalt()
        hashed_pwd = bcrypt.hashpw(mypasswd, salt)

        #print(" ### type(salt) = ", type(salt))
        if (type(salt) is bytes):
            #print(" ### ON VA DECODER")
            salt = salt.decode('UTF-8')
            hashed_pwd = hashed_pwd.decode('UTF-8')


        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()
        """
        # retrieving information
        cur.execute("SELECT username, email_canonical FROM user WHERE id=?", (2,))

        for username, email_canonical in cur:
            print(f"username: {username},  email_canonical : {email_canonical}")
        """

        # insert information
        my_query = "UPDATE user SET salt = '" + str(salt) + "', credentials_expired='0', " \
                                                                 "updated_at='" + str( updated_at) + " ',  " \
                                                                                                     "password = '" + str( hashed_pwd) + "' " \
                                                                                                     " WHERE  " \
                                                                                                     "id='" + str(lms_user_id) + "' " \
                                                                                                                                     "AND  user_id='" + str( lms_user_id) + "' AND   enabled='1' AND  status = '1' AND active = '1' ;"
        try:
            #print(" ### my_query update = ", my_query)
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query)
        except mariadb.Error as e:
            #print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'utilisateur LMS " + str({e}))
            return False, "Impossible de créer l'utilisateur LMS " + str({e}), False

        conn.commit()
        #print(f"Last Inserted ID: {cur.lastrowid}")
        lastrowid = cur.lastrowid

        conn.close()


        return True, " Creation du compte LMS OK. l'id modifié est  = " + str(lastrowid), str(lastrowid)

    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 le compte LMS", False



"""
Cette fonction reactive un compte utilisation dans chamilo. on ne reactive pas les formations, s'il y en a. l'utilisateur doit contacter le support pr cela 
"""
def Enable_MySy_LMS_User(diction):
    try:

        field_list_obligatoire = ['lms_user_id','password' ]

        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, " Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        lms_user_id = ""
        if ("lms_user_id" in diction.keys()):
            if diction['lms_user_id']:
                lms_user_id = diction['lms_user_id']

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

        mypasswd = password.encode('UTF-8')

        salt = bcrypt.gensalt()
        hashed_pwd = bcrypt.hashpw(mypasswd, salt)

        #print(" ### type(salt) = ", type(salt))
        if( type(salt) is bytes ):
            #print(" ### ON VA DECODER")
            salt = salt.decode('UTF-8')
            hashed_pwd = hashed_pwd.decode('UTF-8')


        updated_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()

        # Reactivation du compte dans chamilo
        my_query = "UPDATE user SET active='1',  enabled = '1', " \
                   " salt = '"+str(salt)+"',  password = '"+str(hashed_pwd)+"'  WHERE  id='" + str(lms_user_id) + "' AND  user_id='" + str( lms_user_id) + "'  ;"
        try:
            #print(" ### my_query update = ", my_query)
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query)
        except mariadb.Error as e:
            #print(f"Error: {e}")
            mycommon.myprint(" Impossible de reactiver l'utilisateur LMS " + str({e}))
            return False, "Impossible de reactiver  l'utilisateur LMS " + str({e})

        conn.commit()

        conn.close()


        return True, " Le compte a été correctement activié"

    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 reactiver  le compte LMS"

"""
Cette fonction Desactivment un compte chamilo ansi que les formations associée à ce compte
"""

def Disable_MySy_LMS_User(diction):
    try:

        field_list_obligatoire = ['lms_user_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, " Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        lms_user_id = ""
        if ("lms_user_id" in diction.keys()):
            if diction['lms_user_id']:
                lms_user_id = diction['lms_user_id']

        updated_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()
        cur2 = conn.cursor()

        # Desactivation du compte :
        # Reactivation du compte dans chamilo
        # insert information
        my_query = "UPDATE user SET active='0',  enabled = '0', " \
                   "  updated_at='" + str(updated_at) + "' WHERE  id='" + str(lms_user_id) + "' AND  user_id='" + str(lms_user_id) + "'  ;"
        try:
            #print(" ### my_query update = ", my_query)
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query)
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de desactiver l'utilisateur LMS " + str({e}))
            return False, "Impossible de desactiver l'utilisateur LMS " + str({e})

        conn.commit()


        # Recuperation des formation de cet utilisateur
        cur.execute("SELECT c_id FROM course_rel_user WHERE user_id="+str(lms_user_id))

        for course_id in cur:
            mycommon.myprint(str(inspect.stack()[0][3]) + " Desactivation de la formation_id =  " + str(course_id)+" ")
            # Desactivation du compte dans chamilo
            # insert information
            my_query = "UPDATE course    SET  subscribe='0',  visibility = '0' , expiration_date='" + str(updated_at) + "'  WHERE  id='" + str(course_id[0]) + "'  ;"

            try:
                #print(" ### my_query update = ", my_query)
                # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
                cur2.execute(my_query)
            except mariadb.Error as e:
                print(f"Error: {e}")
                mycommon.myprint(str(inspect.stack()[0][3]) + " IMPOSSIBLE DE Desactiver la formation_id =  " + str(course_id[0]))

        conn.commit()

        # Desactivation des formations créées par ce compte utilisateur

        conn.close()

        return True, " Le compte a été correctement desactive"

    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 desactiver le compte"

"""
Cette fonction desactive le virtualHost / url d'un compte partenaire s'il en a 
"""
def Disable_MySy_LMS_User_VirtualHost_Url(diction):
    try:

        field_list_obligatoire = ['lms_virtualhost_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, " Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        lms_virtualhost_id = ""
        if ("lms_virtualhost_id" in diction.keys()):
            if diction['lms_virtualhost_id']:
                lms_virtualhost_id = diction['lms_virtualhost_id']

        updated_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()
        cur2 = conn.cursor()

        # Desactivation du compte :
        # Reactivation du compte dans chamilo
        # insert information
        my_query = "UPDATE access_url SET active='0' WHERE  id='" + str(lms_virtualhost_id) + "'   ;"
        try:
            #print(" ### my_query update = ", my_query)
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query)
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de desactiver le virtualhost/url " + str({e}))
            return False, "Impossible de desactiver le virtualhost/url  " + str({e})

        conn.commit()


        conn.close()

        return True, " Le virtualHost/url  a été correctement desactive"

    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 desactiver le virtualhost/url "


"""
Cette fonction Reactive le virtualHost / url d'un compte partenaire s'il en a 
"""
def Enable_MySy_LMS_User_VirtualHost_Url(diction):
    try:

        field_list_obligatoire = ['lms_virtualhost_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, " Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        lms_virtualhost_id = ""
        if ("lms_virtualhost_id" in diction.keys()):
            if diction['lms_virtualhost_id']:
                lms_virtualhost_id = diction['lms_virtualhost_id']

        updated_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()
        cur2 = conn.cursor()

        # Desactivation du compte :
        # Reactivation du compte dans chamilo
        # insert information
        my_query = "UPDATE access_url SET active='1' WHERE  id='" + str(lms_virtualhost_id) + "'   ;"
        try:
            #print(" ### my_query update = ", my_query)
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query)
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de desactiver le virtualhost/url " + str({e}))
            return False, "Impossible de desactiver le virtualhost/url  " + str({e})

        conn.commit()


        conn.close()

        return True, " Le virtualHost/url  a été correctement desactive"

    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 desactiver le virtualhost/url "



"""
Cette fonction permet de desactivier les formations d'un utilisateur
"""
def Disable_MySy_LMS_Class_Of_User(diction):
    try:

        field_list_obligatoire = ['lms_user_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, " Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        lms_user_id = ""
        if ("lms_user_id" in diction.keys()):
            if diction['lms_user_id']:
                lms_user_id = diction['lms_user_id']

        updated_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")


        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()
        cur2 = conn.cursor()


        # Recuperation des formation de cet utilisateur
        #print(" ### Disable_MySy_LMS_Class_Of_User : lms_user_id = ", lms_user_id)
        cur.execute("SELECT c_id FROM course_rel_user WHERE user_id='"+str(lms_user_id)+"' ")

        cpt_nb_disable_class = 0
        for course_id in cur:
            cpt_nb_disable_class = cpt_nb_disable_class + 1
            mycommon.myprint(str(inspect.stack()[0][3]) + " Desactivation de la formation_id =  " + str(course_id[0])+" ")
            # Desactivation du compte dans chamilo
            # insert information
            my_query = "UPDATE course    SET  subscribe='0',  visibility = '0' , expiration_date='" + str(updated_at) + "'  WHERE  id='" + str(course_id[0]) + "'  ;"

            try:
                #print(" ### Disable_MySy_LMS_Class_Of_User : my_query update = ", my_query)
                # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
                cur2.execute(my_query)
            except mariadb.Error as e:
                print(f"Error: {e}")
                mycommon.myprint(str(inspect.stack()[0][3]) + " IMPOSSIBLE DE Desactiver la formation_id =  " + str(course_id[0]))

        conn.commit()

        # Desactivation des formations créées par ce compte utilisateur
        conn.close()

        #print(" ### "+str(cpt_nb_disable_class)+" formations de l'utilisateur ont été bien desactivées" )

        return True, str(cpt_nb_disable_class)+" formations de l'utilisateur ont été bien desactivées"

    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 desactiver le compte"




"""
Cette fonction permet de mettre à jour 
- le pack abonnement et
- le nombre max de formations
"""
def Update_Pack_MySy_LMS_User(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',  'lms_user_id', 'mysy_pack', 'mysy_nb_formation']

        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 autorisé", False

        '''
        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',  'lms_user_id', 'mysy_pack', 'mysy_nb_formation']

        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, " Toutes les informations obligatoire n'ont pas été fournies", False

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_token = diction['token']

        partner_recid = ""
        # Verification de la validité du token/mail dans le cas des user en mode connecté
        if (len(str(my_token)) > 0):
            retval = mycommon.check_partner_token_validity("", my_token)

            if retval is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide")
                return False, " Impossible de mettre à jour le compte LMS", False

            # Recuperation du recid de l'utilisateur
            partner_recid = mycommon.get_parnter_recid_from_token(my_token)
            if partner_recid is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire")
                return False, " Impossible de récupérer le token du partenaire", False

        if (len(str(my_token)) <= 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le token est vide")
            return False, " Impossible de mettre à jour le compte LMS", False



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


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


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



        updated_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()

        """ MISE à JOUR DU mysy_pack """
        query_get_mysy_pack_id = "select id from extra_field  where variable = 'mysy_pack' "
        #print(" ### query_get_mysy_pack_id = ", query_get_mysy_pack_id)
        mysy_pack_id = cur.execute(query_get_mysy_pack_id)

        mysy_pack_id_val = ""
        for mysy_pack_id in cur:
            print(f"mysy_pack_id: ", mysy_pack_id[0] )
            mysy_pack_id_val = mysy_pack_id[0]



        query_2 = "select id from extra_field_values  where  field_id = '"+str(mysy_pack_id_val)+"' and item_id = '"+str(lms_user_id)+"' "
        #print(" ### query_2 = ", query_2)
        mysy_pack_id2 = cur.execute(query_2)

        mysy_pack_id_val2 = ""
        for mysy_pack_id2 in cur:
            #print(f"mysy_pack_id2: ", mysy_pack_id2[0])
            mysy_pack_id_val2 = mysy_pack_id2[0]



        query_get_mysy_nb_formation_id = "select id from extra_field  where variable = '" + str(mysy_nb_formation) + "' "

        now = date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        localquery = ""

        if( str(mysy_pack_id_val2).strip() != ""):
            localquery = "update extra_field_values set extra_field_values.value ='" + str(
                mysy_pack) + "' where  id = '" + str(mysy_pack_id_val2) + "'  "

        elif( str(mysy_pack_id_val2).strip() == ""):
            #print(" #### la ligne n'existe pas, il faut la créer ")
            localquery = " INSERT INTO extra_field_values SET   field_id = '"+str(mysy_pack_id_val)+"' ,  " \
                                                                  " item_id = '"+str(lms_user_id)+"'," \
                                                                   " created_at =  '"+now+"', updated_at = '" + now + "', " \
                                                                   " value = '"+str(mysy_pack)+"' "



        #print(" ### localquery = ", localquery)

        try:
            #print(" ### my_query update = ", localquery)
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(localquery)
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'utilisateur LMS " + str({e}))
            return False, "Impossible de créer l'utilisateur LMS " + str({e}), False


        conn.commit()

        """ MISE à JOUR DU mysy_nb_formation """
        query_get_mysy_pack_id = "select id from extra_field  where variable = 'mysy_nb_formation' "
        #print(" ### query_get_mysy_pack_id = ", query_get_mysy_pack_id)
        mysy_pack_id = cur.execute(query_get_mysy_pack_id)

        mysy_pack_id_val = ""
        for mysy_pack_id in cur:
            print(f"mysy_pack_id: ", mysy_pack_id[0])
            mysy_pack_id_val = mysy_pack_id[0]

        query_2 = "select id from extra_field_values  where  field_id = '" + str(
            mysy_pack_id_val) + "' and item_id = '" + str(lms_user_id) + "' "
        #print(" ### query_2 = ", query_2)
        mysy_pack_id2 = cur.execute(query_2)

        mysy_pack_id_val2 = ""
        for mysy_pack_id2 in cur:
            #print(f"mysy_pack_id2: ", mysy_pack_id2[0])
            mysy_pack_id_val2 = mysy_pack_id2[0]

        query_get_mysy_nb_formation_id = "select id from extra_field  where variable = '" + str(
            mysy_nb_formation) + "' "

        localquery = ""

        if (str(mysy_pack_id_val2).strip() != ""):
            localquery = "update extra_field_values set extra_field_values.value ='" + str(
                mysy_nb_formation) + "' where  id = '" + str(mysy_pack_id_val2) + "'  "

        elif (str(mysy_pack_id_val2).strip() == ""):
            #print(" #### la ligne n'existe pas, il faut la créer ")
            localquery = " INSERT INTO extra_field_values SET   field_id = '" + str(mysy_pack_id_val) + "' ,  " \
                                                                                                        " item_id = '" + str(
                lms_user_id) + "'," \
                               " created_at =  '" + now + "', updated_at = '" + now + "', " \
                                                          " value = '" + str(mysy_nb_formation) + "' "



        #print(" ### localquery = ", localquery)

        try:
            #print(" ### my_query update = ", localquery)
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(localquery)
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'utilisateur LMS " + str({e}))
            return False, "Impossible de créer l'utilisateur LMS " + str({e}), False

        conn.commit()

        return True, " Creation du compte LMS OK. l'id modifié est  = ", 1

    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 le compte LMS", False


"""
Cette fonction verifie si un client mysy existe sur chamilo.
Si le client n'existe pas, il le crée avec le pack et le bon nombre de formation
/!\ : On stock dans mysy (collection partnair_account) l'id chamilo du user.
    le nom du champ est : mysy_lms_user_id/

/!\ : si le pack utilisateur necessite d'avoir un compte LMS, 3 cas de figures se posent :
   1 - C'est un tout nouveau compte, alors on le crée simplement
   2 - CAS CRITIQUE : C'est un ancien compte qui a changé plusieurs de fois de pack. il est passé d'un pack avec LMS vers un compte sans LMS puis vers un compte avec LMS.
       dans cas, on reative simplement le compte. 

    3 - Cas d'un client qui passe d'un pack avec LMS vers un pack sans LMS, dans ce cas on desactive le compte LSM, on desacrive ses formations aussi.
   """
def Check_MySy_LMS_Account(diction):
    try:

        # Verification des champs
        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'est pas autorisé")
                return False, str(inspect.stack()[0][3]) +"  Le champ  '" + val + "' n'est pas autorisé"

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

        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, str(inspect.stack()[0][ 3]) +" Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_token = diction['token']

        partner_recid = ""
        # Verification de la validité du token/mail dans le cas des user en mode connecté
        if (len(str(my_token)) > 0):
            retval = mycommon.check_partner_token_validity("", my_token)

            if retval is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide")
                return False, " Impossible de créer le compte LMS"

            # Recuperation du recid de l'utilisateur
            partner_recid = mycommon.get_parnter_recid_from_token(my_token)
            if partner_recid is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire")
                return False, " Impossible de récupérer le token du partenaire"

        if (len(str(my_token)) <= 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le token est vide")
            return False, " Impossible de créer le compte LMS"


        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if( local_status is False ):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, str(inspect.stack()[0][3]) +"  - impossible de récupérer les données du partenaire"

        #print(" ###  my_partner = ", str(my_partner))
        mysy_lms_user_id = ""
        if ("mysy_lms_user_id" in my_partner.keys()):
            if my_partner['mysy_lms_user_id']:
                mysy_lms_user_id = my_partner['mysy_lms_user_id']


        pack_service = ""
        if ("pack_service" in my_partner.keys()):
            if my_partner['pack_service']:
                pack_service = my_partner['pack_service']


        # Recuperation des caracterisques du pack
        pack_data = MYSY_GV.dbname['pack'].find_one({'code_pack':str(pack_service).lower()})
        if( pack_data is None ):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du pack (1)")
            return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du pack (1)"

        lms_account = ""
        if ("lms_account" in pack_data.keys()):
            if pack_data['lms_account']:
                lms_account = pack_data['lms_account']

        if (lms_account != "0" and lms_account != "1")  :
            mycommon.myprint(str(inspect.stack()[0][3]) + " - lms_account est incorrecte  ")
            return False, str(inspect.stack()[0][3]) + "  - lms_account est incorrecte  "

        if( lms_account == "1"):
            """
            Ce pack necessite un compte LMS
            """
            if( mysy_lms_user_id.strip() == ""):
                #print(" ### ce partenaire n'as pas de compte LMS, il faut en créer 1 ")

                new_diction = {}
                lastname = ""
                if ("contact_nom" in my_partner.keys()):
                    if my_partner['contact_nom']:
                        lastname = my_partner['contact_nom']
                if( lastname == ""):
                    lastname = my_partner['invoice_nom']


                firstname = ""
                if ("contact_prenom" in my_partner.keys()):
                    if my_partner['contact_prenom']:
                        firstname = my_partner['contact_prenom']
                if (firstname == ""):
                    firstname = my_partner['invoice_nom']

                new_diction['token'] = my_partner['token']
                new_diction['lastname'] = lastname
                new_diction['firstname'] = firstname
                new_diction['email'] = my_partner['email']
                new_diction['password'] = my_partner['pwd']
                new_diction['locked'] = "0"
                new_diction['official_code'] = ""
                split_mail_tab = str(my_partner['email']).split('@')
                new_diction['username'] = split_mail_tab[0]


                local_status, local_retval, new_lms_use_id = Create_MySy_LMS_User(new_diction)
                if (local_status is False):
                    mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de créer le compte LMS  ")
                    return False, str(inspect.stack()[0][3]) + "  - Impossible de créer le compte LMS "

                # Apres la creation du compte LSM, on met à jour le compte mysy avec la valeur du champs : mysy_lms_user_id
                mysy_coll_query = {}
                mysy_coll_query['mysy_lms_user_id'] = str(new_lms_use_id)
                mysy_coll_query['date_update'] = str(datetime.now())
                ret_val = MYSY_GV.dbname['partnair_account'].find_one_and_update(
                    {'recid': my_partner['recid'], 'active': '1', 'locked': '0'},
                    {"$set": mysy_coll_query},
                    upsert=False,
                    return_document=ReturnDocument.AFTER
                )

                if (ret_val['_id'] is False):
                    mycommon.myprint(
                        str(inspect.stack()[0][
                                3]) + " : WARNING :  Impossible de mettre à jour le compte MySy avec le mysy_lms_user_id =  ",
                        str(mysy_lms_user_id))


            else:
                print(" ### ce partenaire A un compte. il faut mettre à jour le compte LMS avec le nouveau pack, le nombre max de formation")
                """ 
                /!\ il ne faut pas oublier de gerer le cas ou le client à plus de cours de activé dans chamilo.
                une solition est serai de refuser tout changement tant que le nombre de formation dans mysy et dans lms ne sont pas cohérent.
                 DONC LE CONTROLE EST A FAIRE BIEN EN AMONT
                
                """
                # Reactivation du compte utilisateur
                new_diction = {}
                new_diction['password'] = my_partner['pwd']
                new_diction['lms_user_id'] = my_partner['mysy_lms_user_id']
                print(" ### Ractivation du compte utilisation mysy_lms_user_id = ", my_partner['mysy_lms_user_id'])
                local_status, local_retval = Enable_MySy_LMS_User(new_diction)
                if (local_status is False):
                    mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de reactiver le  compte LSM  ")
                    return False, str(inspect.stack()[0][3]) + "  - Impossible de reactiver  le compte LSM "

                # Reactivation du virtualHost s'il en a 1
                if( "lms_virtualhost_id" in my_partner.keys() ) :
                    if(  my_partner['lms_virtualhost_id'] ):
                        new_diction = {}
                        new_diction['lms_virtualhost_id'] = my_partner['lms_virtualhost_id']
                        print(" ### Ractivation du virtualHost/url  lms_virtualhost_id = ", my_partner['lms_virtualhost_id'])
                        local_status, local_retval = Enable_MySy_LMS_User_VirtualHost_Url(new_diction)
                        if (local_status is False):
                            mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de reactiver le virtualHost/url  du compte  ")
                            return False, str(inspect.stack()[0][3]) + "  - Impossible de reactiver le virtualHost/url  du compte  "


                # Mise à jour des autres info.
                new_diction = {}
                new_diction['token'] = my_partner['token']
                new_diction['lms_user_id'] = my_partner['mysy_lms_user_id']
                new_diction['mysy_pack'] = my_partner['pack_service']
                new_diction['mysy_nb_formation'] = my_partner['nb_formation']

                #print(" ### stored mysy_nb_formation = ", my_partner['nb_formation'])

                local_status, local_retval, new_lms_use_id = Update_Pack_MySy_LMS_User(new_diction)
                if (local_status is False):
                    mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de mettre à jour  le compte LSM  ")
                    return False, str(inspect.stack()[0][3]) + "  - Impossible de mettre à jour  le compte LSM "



        elif (lms_account == "0"):
            print(" ###  Ce pack NE necessite PAS un compte LMS ")
            """
            Ce pack NE necessite PAS un compte LMS. il faut donc verifier si le partenaire à deja un compte, au quel
            cas il faut le desactiver
            """
            if (mysy_lms_user_id.strip() != ""):
                print(" ###  Ce partenaire a deja un compte LMS, il faut donc le desactiver, PUIS desactiver son virtualhost s'il en a  ")
                """
                Ce partenaire a deja un compte LMS, c'est donc une mise à jour qu'il faut faire
                """
                new_diction = {}
                new_diction['lms_user_id'] = my_partner['mysy_lms_user_id']
                local_status, local_retval = Disable_MySy_LMS_User(new_diction)
                if (local_status is False):
                    mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de desactiver   le compte LSM  ")
                    return False, str(inspect.stack()[0][3]) + "  - Impossible de desactiver le compte LSM "

                new_diction = {}
                new_diction['lms_virtualhost_id'] = my_partner['lms_virtualhost_id']
                local_status, local_retval = Disable_MySy_LMS_User_VirtualHost_Url(new_diction)
                if (local_status is False):
                    mycommon.myprint(str(inspect.stack()[0][3]) + " - WARNING Impossible de desactiver  le virtualHost/url ")



        return True, " Creation/mise à jour du compte LSM ok"

    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 le compte LMS : Check_MySy_LMS_User "


"""
Cette fonction retourne le nombre de formations actives dans mysy et dans le lms
la valeur retournée est de type : true, nb_active_mysy, nb_active_lms, message
"""
def Get_Active_Ftions_Mysy_and_Lms(diction):
    try:

        # Verification des champs
        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'est pas autorisé")
                return False, False, False, str(inspect.stack()[0][3]) + "  Le champ  '" + val + "' n'est pas autorisé"

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

        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, False, False, str(inspect.stack()[0][3]) + " Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_token = diction['token']

        partner_recid = ""
        # Verification de la validité du token/mail dans le cas des user en mode connecté
        if (len(str(my_token)) > 0):
            retval = mycommon.check_partner_token_validity("", my_token)

            if retval is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide")
                return False, False, False, str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide"

            # Recuperation du recid de l'utilisateur
            partner_recid = mycommon.get_parnter_recid_from_token(my_token)
            if partner_recid is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire")
                return False, False, False, str(inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire"

        if (len(str(my_token)) <= 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le token est vide")
            return False, False, False, str(inspect.stack()[0][3]) + " - Le token est vide"

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, False, False, " - impossible de récupérer les données du partenaire"

        # print(" ###  my_partner = ", str(my_partner))
        mysy_lms_user_id = ""
        if ("mysy_lms_user_id" in my_partner.keys()):
            if my_partner['mysy_lms_user_id']:
                mysy_lms_user_id = my_partner['mysy_lms_user_id']



        # recup du nombre de formations actives et publiées dans mysy
        mysy_count = MYSY_GV.dbname['myclass'].count_documents({'locked':'0', 'valide':'1', 'published':'1',
                                                                'partner_owner_recid':str(my_partner['recid'])})

        # recup du nombre de formations actives et publiées dans le LMS
        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()

        lms_count_qry = "select count(*) from course  as a left join course_rel_user as b on a.id = b.c_id where  a.visibility != '0' and b.user_id = '"+mysy_lms_user_id+"' "
        #print(" ### lms_count_qry = ", lms_count_qry)
        lms_count_exec = cur.execute(lms_count_qry)

        lms_count_courses = ""
        lms_count_courses_val = "0"
        for lms_count_courses in cur:
            #print(f"lms_count_courses_val: ", lms_count_courses[0])
            lms_count_courses_val = lms_count_courses[0]


        return True, mysy_count,lms_count_courses_val,  " "

    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, False, False, " Impossible de récupérer le nombre de formations actives dans mysy et le lms "

"""
Cette fonction permet d'inscrire un utilisateur à une formation.
cas d'utilisation : 
Lorque le formateur valide l'inscription sur Mysy, on va aller inscrire l'utilisateur
à la formation
"""
def Add_User_To_LMS_Class(diction):
    try:

        # Verification des champs
        field_list = ['token', 'user_lms_id', 'course_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, str(inspect.stack()[0][3]) + "  Le champ  '" + val + "' n'est pas autorisé"

        '''
        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', 'user_lms_id', 'course_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 liste ")
                return False,  str(
                    inspect.stack()[0][3]) + " Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_token = str(diction['token']).strip()

        course_code = ""
        if ("course_code" in diction.keys()):
            if diction['course_code']:
                course_code = str(diction['course_code']).strip()

        user_lms_id = ""
        if ("user_lms_id" in diction.keys()):
            if diction['user_lms_id']:
                user_lms_id = str(diction['user_lms_id']).strip()

        partner_recid = ""
        # Verification de la validité du token/mail dans le cas des user en mode connecté
        if (len(str(my_token)) > 0):
            retval = mycommon.check_partner_token_validity("", my_token)

            if retval is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide")
                return False, str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide"

            # Recuperation du recid de l'utilisateur
            partner_recid = mycommon.get_parnter_recid_from_token(my_token)
            if partner_recid is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire")
                return  False, str(
                    inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire"

        if (len(str(my_token)) <= 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le token est vide")
            return False, str(inspect.stack()[0][3]) + " - Le token est vide"

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, " - impossible de récupérer les données du partenaire"

        # print(" ###  my_partner = ", str(my_partner))
        mysy_lms_user_id = ""
        if ("mysy_lms_user_id" in my_partner.keys()):
            if my_partner['mysy_lms_user_id']:
                mysy_lms_user_id = my_partner['mysy_lms_user_id']


        updated_at = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()
        cur2 = conn.cursor()

        """ Verifier si l'utilisateur n'est pas deja inscrit à cette formation  """
        #query = "select count(*) from  course_rel_user  where user_id = '"+str(user_lms_id)+"' and c_id = '"+str(course_code)+"' "
        query = "select  count(*), b.id from  course_rel_user as a left join course as b on a.c_id = b.id  where user_id = '"+str(user_lms_id)+"' and b.code  = '"+str(course_code)+"'"
        #print(" ### query_get_mysy_pack_id = ", query)
        cur.execute(query)

        count_inscription_user = ""
        count_inscription_user_val = ""

        for count_inscription_user in cur:
            count_inscription_user_val = count_inscription_user[0]

        if (int(mycommon.tryInt(count_inscription_user_val)) > 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Cet utilisateur est déjà inscrit à cette formation")
            return False, " - Cet utilisateur est déjà inscrit à cette formation"

        """ Verifier que la formation existe et est valide """
        query = "select count(*), id from  course   where visibility != '0' and code = '" + str(course_code) + "' "
        print(" ### query = ", query)
        cur.execute(query)

        count_course_valide = ""
        count_course_valide_val = ""
        course_id = ""

        for count_course_valide in cur:
            #print(" ### count_course_valide = ", count_course_valide)
            count_course_valide_val = count_course_valide[0]
            course_id = count_course_valide[1]

        if (int(mycommon.tryInt(count_course_valide_val)) <= 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Cette formation n'est pas valide/active")
            return False, " - Cette formation n'est pas valide/active"

        if (int(mycommon.tryInt(count_course_valide_val)) < 1):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Ce code formation correspond à plusieurs formations actives")
            return False, " - Ce code formation correspond à plusieurs formations actives"

        my_query = " INSERT INTO course_rel_user (user_id, c_id, relation_type, status  ) " \
                   " VALUES('"+str(user_lms_id)+"', '"+str(course_id)+"', 0, 5 );"
        cur2 = conn.cursor()
        try:
            print(" ### my_query bbb = ", my_query)
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur2.execute(my_query)

        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'utilisateur LMS " + str({e}))
            return False, "Impossible d'inscrire l'utilisateur à la formation " + str({e})

        conn.commit()
        conn.close()

        return True, " ok "

    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 d'inscrire l'utilisateur à la formation "



"""
Cette fonction permet de desincrire un utilisateur à une formation
important : c'est un simple delete qu'il faut faire sur la table "course_rel_user"
"""
def Remove_User_From_LMS_Class(diction):
    try:
        # Verification des champs
        field_list = ['token', 'user_lms_id', 'course_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,  str(inspect.stack()[0][3]) + "  Le champ  '" + val + "' n'est pas autorisé"

        '''
        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', 'user_lms_id', 'course_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 liste ")
                return False, str(
                    inspect.stack()[0][3]) + " Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_token = diction['token']

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

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

        partner_recid = ""
        # Verification de la validité du token/mail dans le cas des user en mode connecté
        if (len(str(my_token)) > 0):
            retval = mycommon.check_partner_token_validity("", my_token)

            if retval is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide")
                return False, str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide"

            # Recuperation du recid de l'utilisateur
            partner_recid = mycommon.get_parnter_recid_from_token(my_token)
            if partner_recid is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire")
                return False,  str(
                    inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire"

        if (len(str(my_token)) <= 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le token est vide")
            return False, str(inspect.stack()[0][3]) + " - Le token est vide"

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False,  " - impossible de récupérer les données du partenaire"

        # print(" ###  my_partner = ", str(my_partner))
        mysy_lms_user_id = ""
        if ("mysy_lms_user_id" in my_partner.keys()):
            if my_partner['mysy_lms_user_id']:
                mysy_lms_user_id = my_partner['mysy_lms_user_id']

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()

        """ Verifier si l'utilisateur est  deja inscrit à cette formation  """
        query = "select  count(*), a.id from  course_rel_user as a left join course as b on a.c_id = b.id  where user_id = '" + str(
            user_lms_id) + "' and b.code  = '" + str(course_code) + "'"
        print(" ### query_get_mysy_pack_id = ", query)
        cur.execute(query)

        count_inscription_user = ""
        count_inscription_user_val = ""
        course_rel_user_id = ""

        for count_inscription_user in cur:
            count_inscription_user_val = count_inscription_user[0]
            course_rel_user_id = count_inscription_user[1]


        if (int(mycommon.tryInt(count_inscription_user_val)) < 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Cet utilisateur n'est pas à cette formation")
            return True, " - Cet utilisateur n'est pas à cette formation"

        my_query = " Delete from course_rel_user WHERE id = '" + str(course_rel_user_id) + "';"
        cur2 = conn.cursor()
        try:
            print(" ### my_query ccc = ", my_query)
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur2.execute(my_query)

        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'utilisateur LMS " + str({e}))
            return False, "Impossible d'inscrire l'utilisateur à la formation " + str({e})

        conn.commit()
        conn.close()

        return True, " l'inscription a bien été annulé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, False, False, " Impossible de desincrire l'utilisateur à la formation "


"""
Cette fonction permet de créer un apprenant.
use case : 
Lorsqu'une inscription est validée sur mysy, on va créer le user apprenant 
:!\ : a ne pas confondre avec la creation d'un utilisateur enseignant """
def Create_MySy_LMS_Apprenant(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', 'lastname', 'firstname', 'email', 'password', 'locked', 'username']

        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 autorisé", False

        '''
        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', 'lastname', 'firstname', 'email', 'password', 'locked']

        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, " Toutes les informations obligatoire n'ont pas été fournies", False

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_token = diction['token']

        partner_recid = ""
        # Verification de la validité du token/mail dans le cas des user en mode connecté
        if (len(str(my_token)) > 0):
            retval = mycommon.check_partner_token_validity("", my_token)

            if retval is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - La session de connexion n'est pas valide")
                return False, " Impossible de créer le compte LMS", False

            # Recuperation du recid de l'utilisateur
            partner_recid = mycommon.get_parnter_recid_from_token(my_token)
            if partner_recid is False:
                mycommon.myprint(str(inspect.stack()[0][3]) + " - Impossible de récupérer le token du partenaire")
                return False, " Impossible de récupérer le token du partenaire", False

        if (len(str(my_token)) <= 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le token est vide")
            return False, " Impossible de créer le compte LMS", False

        # Recuperation des données du partenaire qui est propritaire de la formation
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire proprietaire de la formation")
            return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du partenaire proprietaire de la formation"

        # On affecte le lms_virtualhost_id par defaut à la racine, donc le site principale.
        # Si le propritaire de la formation à un 'lms_virtualhost_id' dédié, on remplace le principale par celui du proprio
        lms_virtualhost_id = "1"
        if ("lms_virtualhost_id" in my_partner.keys()):
            if my_partner['lms_virtualhost_id']:
                lms_virtualhost_id = my_partner['lms_virtualhost_id']


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

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

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

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

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

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

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

        registration_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")





        mypasswd  = password.encode('UTF-8')

        salt = bcrypt.gensalt()
        hashed_pwd = bcrypt.hashpw(mypasswd, salt)


        if (type(salt) is bytes):
            salt = salt.decode("UTF-8")
            hashed_pwd = hashed_pwd.decode("UTF-8")

        """
        """
        mysy_sequence_id = ""

        # Rcuperation de la sequence de l'objet "lms_user_id" dans la collection : "mysy_sequence"
        retval = MYSY_GV.dbname['mysy_sequence'].find_one({'related_mysy_object': 'lms_user_id', 'valide': '1',
                                                           'partner_owner_recid': str(my_partner['recid'])})

        if (retval is None or "current_val" not in retval.keys()):

            # Il n'a pas de sequence pour ce partenaire, verifier s'il ya une sequence par defaut
            retval = MYSY_GV.dbname['mysy_sequence'].find_one({'related_mysy_object': 'lms_user_id', 'valide': '1',
                                                               'partner_owner_recid': "default"})

            if (retval is None or "current_val" not in retval.keys()):
                mycommon.myprint(" Aucune séquence 'lms_user_id' n'est paramétré dans le système ")
                return False, " Aucune séquence 'lms_user_id' n'est paramétré dans le système ", False

        # on stock l'id trouvé
        mysy_sequence_id = str(retval['_id'])


        """
        """


        new_lms_user_id = str(retval['prefixe'])+str(retval['current_val'])
        local_status, local_val = mycommon.IsInt(new_lms_user_id)
        if( local_status is False):
            mycommon.myprint(" Impossible de generer l'ID du user LMS. La valeur actuelle est ", new_lms_user_id)
            return False, " Impossible de generer l'ID du user LMS", False

        current_seq_value = str(retval['current_val'])

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()
        """
        # retrieving information
        cur.execute("SELECT username, email_canonical FROM user WHERE id=?", (2,))

        for username, email_canonical in cur:
            print(f"username: {username},  email_canonical : {email_canonical}")
        """
        # Verification d'abord si le compte exite.
        query_compte_exist = " Select count(*), user_id From  user WHERE username = '"+username+"' "
        print(" ### query_compte_exist = ", query_compte_exist)
        query_compte_exist_exec = cur.execute(query_compte_exist)

        query_compte_exist_exec = ""
        query_compte_exist_exec_val = "0"
        for query_compte_exist_exec in cur:
            query_compte_exist_exec_val = query_compte_exist_exec[0]
            if (int(mycommon.tryInt(query_compte_exist_exec_val)) > 0):
                new_lms_user_id = query_compte_exist_exec[1]
        conn.commit()


        if( int(mycommon.tryInt(query_compte_exist_exec_val)) > 0  ):
            # Le compte existe, il faut donc faire une mise à jour
            my_query = "UPDATE user SET salt = '" + str(salt) + "', credentials_expired='0', " \
                                                                "updated_at='" + str(registration_date) + " ',  " \
                                                                                                          "password = '" + str(
                hashed_pwd) + "', " \
                              "enabled='1', " \
                              "expired='0',  " \
                              "locked = '0', " \
                              "auth_source = 'platform'," \
                              "roles = 'a:0:{}', " \
                              "language = 'french'," \
                              "username_canonical = '" + username + "', " \
                                                                    " email_canonical = '" + email + "', " \
                                                                                                     "email = '" + email + "'," \
                                                                                                                           " official_code	= '" + official_code + "', " \
                                                                                                                                                                     "active = '1' WHERE  username='" + str(
                email) + "' ;"
        else:
            # Le compte n'existe pas, il faut le créer


            # insert information
            my_query = "INSERT INTO user SET id='"+str(new_lms_user_id)+"' ,  " \
                                                                        "user_id='"+str(new_lms_user_id)+"' , " \
                                                                                                         "lastname = '"+lastname+"', " \
                                                                                                         "firstname = '"+firstname+"',  " \
                                                                                                         "username = '"+username+"', " \
                                                                                                         "salt = '"+str(salt)+"'," \
                                                                                                         " registration_date = '"+registration_date+"'," \
                                                                                                         " credentials_expired='0', " \
                                                                                                         "enabled='1', " \
                                                                                                         "expired='0',  " \
                                                                                                                                                    "created_at='" + str( registration_date) + "'," \
                                                                                                                                                                                               "  updated_at='" + str( registration_date) + "', " \
                                                                                                                                                                                                                                            " status = '5', " \
                                                                                                         "password = '"+str(hashed_pwd)+"', " \
                                                                                                         "locked = '0', " \
                                                                                                         "username_canonical = '"+username+"', " \
                                                                                                         " email_canonical = '"+email+"', " \
                                                                                                         "email = '"+email+"'," \
                                                                                                         " official_code	= '"+official_code+"', " \
                                                                                                         "creator_id  = '1', " \
                                                                                                         "auth_source = 'platform'," \
                                                                                                         "roles = 'a:0:{}', " \
                                                                                                         "language = 'french'," \
                                                                                                         "active = '1';"

        try:
            print(" ### my_query ddd = ", my_query)
            #cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query)
        except mariadb.Error as e:
            #print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'utilisateur LMS "+str({e}))
            return False, "Impossible de créer l'utilisateur LMS "+str({e}), False

        conn.commit()
        #print(f"Last Inserted ID: {cur.lastrowid}")

        lastrowid = cur.lastrowid

        my_query_access_url_rel_user = "INSERT INTO access_url_rel_user SET access_url_id='"+str(lms_virtualhost_id)+"' ,  user_id='" + str(
            new_lms_user_id) + "'  "
        print(" ### my_query_access_url_rel_user = ", my_query_access_url_rel_user)

        try:

            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query_access_url_rel_user)
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(str(inspect.stack()[0][3]) + " WARNING - impossible d'ajouter le user '" + str(
                new_lms_user_id) + "'  à la table access_url_rel_user pour la recheche et l'envoi des email")

        conn.commit()

        conn.close()

        # Crementation de la sequence de l'objet "lms_user_id" dans la collection : "mysy_sequence"

        #print(" ### current_seq_value = ", current_seq_value)
        new_sequence_value = int(mycommon.tryInt(current_seq_value))+1

        mydata = {'current_val':new_sequence_value}
        ret_val2 = MYSY_GV.dbname['mysy_sequence'].find_one_and_update({'_id':ObjectId(str(mysy_sequence_id))},
                                                        {"$set": mydata},
                                                        return_document=ReturnDocument.AFTER,
                                                                       upsert= False,
                                                        )


        return  True, " Creation du compte LMS OK. l'id = "+str(new_lms_user_id), str(new_lms_user_id)

    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 le compte LMS", False


"""
Cette fonction renvoie les information LMS d'un partner.
Elle verifie si l'abonnement du partner necessite un LMS
- has_lms_acces
- url (dev, rec ou prod)
- lms_user_id
- lms_userid (login)
- lms pwd
- lms_virtualhost_url
"""

def LMS_Get_Partner_Data(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']
        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, Creation participants annulée")
                return False, " Les informations fournies sont incorrecte"

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

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

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

        local_status, connected_user_data = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
        if (local_status is not True):
            return local_status, connected_user_data


        print(" #### connected_user_data = ", connected_user_data)

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

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du partenaire"


        if ("pack_service" not in my_partner.keys()):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - Le partenaire n'as pas d'abonnement ")
            return False, "  Le partenaire n'as pas d'abonnement"

        # Recuperation des données du pack
        pack_data = MYSY_GV.dbname['pack'].find_one({'code_pack':str(my_partner['pack_service']).lower(), 'valide':'1'})

        if( pack_data is None ):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du pack de service")
            return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du pack de service"

        if ("lms_account" not in pack_data.keys()):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - La configuration de l'acces au LMS est incorrect")
            return False, "  La configuration de l'acces au LMS est incorrect"

        lms_account = pack_data['lms_account']
        lms_user_id = ""
        lms_user_name = ""
        lms_pwd_mask = ""
        lms_part_recid = ""
        lms_virtualhost_url = ""
        lms_url = ""
        if( lms_account == "1"):
            lms_user_id = connected_user_data['mysy_lms_user_id']
            lms_user_name = my_partner['email']
            #lms_pwd_mask = my_partner['pwd']
            #lms_part_recid = my_partner['recid']
            lms_part_recid = str(connected_user_data['_id'])
            lms_pwd_mask = str(connected_user_data['pwd'])
            lms_virtualhost_url = my_partner['lms_virtualhost_url']
            lms_url = MYSY_GV.MYSY_LMS_URL

            """
             /!\ On va brouiller le mot de passe en le recomposant comme suit :
            
                            pwd_brouillé =  'mSyt'+$mysy_lms_user_id+"$date_day+$pwd.
                            par exemple, pour un mot de passe = "toto"
                            en date du 30/03/2023, la valeur du champs mysytoken = "mSyt1002030toto"
                            
                L'objectif est que seul un système qui connait les algoritme coté front office peut l'utiliser. 
                Ainsi on evite de balader le mot de passe.
            
            """

        day_on_2_digit = '{:02d}'.format(datetime.now().day)
        lms_pwd_mask = "mSyt"+str(lms_user_id)+str(day_on_2_digit)+str(connected_user_data['pwd'])

        val_tmp = {}
        val_tmp['lms_account'] = lms_account
        val_tmp['lms_user_id'] = lms_user_id
        val_tmp['lms_user_name'] = lms_user_name
        val_tmp['lms_pwd_mask'] = lms_pwd_mask
        val_tmp['lms_part_recid'] = lms_part_recid
        val_tmp['lms_virtualhost_url'] = lms_virtualhost_url
        val_tmp['lms_url'] = lms_url

        insertObject = []
        insertObject.append(mycommon.JSONEncoder().encode(val_tmp))

        return True, insertObject

    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 LMS du partner"


"""
Une fois un compte LMS créé, cette fonction donne la possibilité de créer
une virtualhost associé à cet utilisateur
Le virtualhost revient à créer dans base de donnée de chamilo, la table "access_url" un enregistrement
- url,
- description
- active, 
- date heure creation
"""
def LMS_Create_VirtualHost(diction):
    try:
        virtualHost_Id = ""
        virtualHost_url = ""
        '''
                       # 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', 'lms_username']
        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, Creation virtualhost annulée")
                return False, " Les informations fournies sont incorrecte", virtualHost_Id, virtualHost_url

        '''
        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', 'lms_username']
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
                return False, " Les informations fournies sont incorrecte", virtualHost_Id, virtualHost_url

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

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

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

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du partenaire", virtualHost_Id, virtualHost_url

        if ("nom" not in my_partner.keys()):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - Le nom du partenaire est incorrect ")
            return False, " Le nom du partenaire est incorrect ", virtualHost_Id, virtualHost_url

        part_nom = my_partner['nom']
        local_status, part_nom = mycommon.local_Remove_Ponct_Special_Caractere(str(part_nom))
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de verifier le nom du partenaire")
            return False, str(inspect.stack()[0][3]) + "  - impossible de verifier le nom du partenaire", virtualHost_Id, virtualHost_url


        """
        /!\ : la regle pour definir l'url (url.iexercice.com) est : 
        1 - on prend le nom, on enleve tous les caratères non acceptés dans une url
        2 - on met tout en minuscule
        3 - Du mot restant, on prends les 10 premiers caractère.
        4 - l'url global = prefixe_url.GV.LMS_BAS_URL
        
        ex : pour un qui est : "MySy Demo 2303"
        prefixe url = mysydemo23
        l'url final est : mysydemo23.iexerice.com
        """

        print(" ### part_nom = ", str(part_nom))
        lms_prefixe_url = ''.join(filter(str.isalnum, part_nom))
        lms_prefixe_url = str(str(lms_prefixe_url)[0:10]).lower()
        if(len(lms_prefixe_url) < 3 ):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - le lms_prefixe_url est trop court. Le nom du client comporte moins de 3 caractères alphanumerique")
            return False, " Impossible de créer l'url dans le LMS. Le lms_prefixe_url est trop court. Le nom du client comporte moins de 3 caractères alphanumerique ", virtualHost_Id, virtualHost_url

        print(" #### lms_prefixe_url = ", lms_prefixe_url)

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )

        cur = conn.cursor()

        # Verification d'abord si l'url existe.
        local_full_url = str(lms_prefixe_url)+"."+str(MYSY_GV.LMS_BAS_URL)
        query_compte_exist = " Select count(*), url  From  access_url WHERE url = '" + local_full_url + "' "
        print(" ### query_compte_exist = ", query_compte_exist)
        query_compte_exist_exec = cur.execute(query_compte_exist)

        query_compte_exist_exec = ""
        query_compte_exist_exec_val = "0"
        existing_url = ""
        for query_compte_exist_exec in cur:
            query_compte_exist_exec_val = query_compte_exist_exec[0]
            if (int(mycommon.tryInt(query_compte_exist_exec_val)) > 0):
                existing_url = query_compte_exist_exec[1]
        conn.commit()

        if(len(existing_url) > 0 ):
            mycommon.myprint(
                str(inspect.stack()[0][
                        3]) + " - L'url '"+str(existing_url)+"' existe deja. Impossible de créer une nouvelle url")
            return False, "  L'url '"+str(existing_url)+"' existe deja. Impossible de créer une nouvelle url ", virtualHost_Id, virtualHost_url

        print(" #### le prefixe d'url :  '"+str(lms_prefixe_url)+"' N'EXISTE PAS. On va créer l'url")
        registration_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        full_url = str("https://"+str(lms_prefixe_url)+"."+str(MYSY_GV.LMS_BAS_URL)).lower()
        full_url = unidecode(full_url)

        virtualHost_url = full_url
        my_query = " INSERT  INTO access_url (url, description, active, created_by, tms, url_type) "\
        " VALUES('"+str(full_url)+"', 'Url pour "+str(part_nom)+"', '1', '1', '"+str(registration_date)+"', NULL);"

        try:
            print(" ### my_query iiii = ", my_query)
            cur.execute(my_query)
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'url LMS " + str({e}))
            return False, "Impossible de créer l'url LMS " + str({e}), virtualHost_Id, virtualHost_url

        conn.commit()

        if( cur.lastrowid ):
            virtualHost_Id = cur.lastrowid


        print(f"Last Inserted ID: {cur.lastrowid}")
        conn.close()

        """ Une fois que l'url/virtualhost a été crée, on met à jour le compte partnair dans MySy
        """
        # Apres la creation du compte LSM, on met à jour le compte mysy avec la valeur du champs : mysy_lms_user_id
        mysy_coll_query = {}
        mysy_coll_query['lms_virtualhost_id'] = str(virtualHost_Id)
        mysy_coll_query['lms_virtualhost_url'] = str(virtualHost_url)
        mysy_coll_query['date_update'] = str(datetime.now())
        mysy_coll_query['lms_username'] = str(lms_username)

        ret_val = MYSY_GV.dbname['partnair_account'].find_one_and_update(
            {'token': diction['token'], 'active': '1', 'locked': '0'},
            {"$set": mysy_coll_query},
            upsert=False,
            return_document=ReturnDocument.AFTER
        )

        if (ret_val['_id'] is False):
            mycommon.myprint(
                str(inspect.stack()[0][
                        3]) + " : WARNING :  Impossible de mettre à jour le compte MySy avec le lms_virtualhost_url =  ",
                str(virtualHost_url))


        return True, " L'url LMS a été correctement crée", virtualHost_Id, virtualHost_url

    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 une url (virtualhost) ", False, False


"""
Cette fonction retourne les theme du LMS.
Cela permettra à une personne de choisir le theme qu'il souhaite pour son 
espace
"""
def Get_Lms_Themes(diction):
    try:

        """
                      Verification de la liste 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 liste ")
                return False, "Impossible de récupérer la liste des themes LMS "

        # Recuperation du recid du partner
        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 récupérer la liste themes LMS (2)")
            return False, "Impossible de récupérer la liste themes LMS (2) "

        RetObject = []
        local_cpt = 0
        for ret_val in MYSY_GV.dbname['lms_theme'].find(
                {"$or": [{"partner_recid": str(partner_recid), "valide": "1"},
                         {"partner_recid": 'default', "valide": "1"}]}):
            if (ret_val and ret_val['_id']):
                RetObject.append(mycommon.JSONEncoder().encode(ret_val))
                local_cpt = local_cpt + 1

        if (local_cpt == 0):
            mycommon.myprint(str(inspect.stack()[0][3]) + " Aucun theme LMS trouvé ")
            return False, " Aucun theme LMS trouvé "

        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 themes LMS "



"""
Cette fonction permet de configurer le theme LMS d'un partenaire
Sur le front il choisi un theme / logo, cette fonction met à jour ces
info dans le lms chamilo.
/!\ : la fonction verifie si un setup existe deja (table  : 'settings_current' avec 
access_url = lms_virtualhost_id (dans mysy du user.)


"""
def Lms_Config_Theme_and_Logo(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', 'theme_name']
        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, Creation virtualhost annulée")
                return False, " Les informations fournies sont incorrecte",

        '''
        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', 'theme_name']
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
                return False, " Les informations fournies sont incorrecte",

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

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

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

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, str(inspect.stack()[0][
                                  3]) + "  - impossible de récupérer les données du partenaire",

        lms_virtualhost_id = ""
        if ("lms_virtualhost_id"  in my_partner.keys()):
                lms_virtualhost_id = my_partner['lms_virtualhost_id']

        if( lms_virtualhost_id == ""):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le user "+str(my_partner['nom'])+" ne dispose pas de d'un lms_virtualhost_id."
                                                                                               " Pas de configuration à faire")
            return False, str(inspect.stack()[0][
                                  3]) + "  -  Le user "+str(my_partner['nom'])+" ne dispose pas de d'un lms_virtualhost_id. Pas de configuration à faire"

        lms_virtualhost_url = ""
        if ("lms_virtualhost_url"  in my_partner.keys()):
                lms_virtualhost_url = my_partner['lms_virtualhost_url']

        if( lms_virtualhost_url == ""):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le user "+str(my_partner['nom'])+" ne dispose pas de d'un lms_virtualhost_url."
                                                                                               " Pas de configuration à faire")
            return False, str(inspect.stack()[0][
                                  3]) + "  -  Le user "+str(my_partner['nom'])+" ne dispose pas de d'un lms_virtualhost_url. Pas de configuration à faire"

        tmp_val = lms_virtualhost_url.replace("http://", '').replace("https://", '')
        tmp_split  = str(tmp_val).split(".")
        new_theme_name = str(lms_virtualhost_id)+"-"+str(tmp_split[0])+"-theme"

        new_diction_local = {}

        new_diction_local['token'] = my_token
        new_diction_local['original_theme_name'] = theme_name
        new_diction_local['new_theme_name'] = new_theme_name

        local_status, local_message = Duplicate_LMS_Theme_Design(new_diction_local)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de dupliquer le thème/design")
            return False, str(inspect.stack()[0][
                                  3]) + "  - impossible de dupliquer le thème/design",


        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )

        cur = conn.cursor()

        lms_count_qry = "select count(*) from settings_current where access_url = '" + lms_virtualhost_id + "'  AND variable='stylesheets' " \
                                                                                                               " AND category='stylesheets' ;"

        print(" ### lms_count_qry = ", lms_count_qry)

        lms_count_exec = cur.execute(lms_count_qry)
        lms_count_courses = ""
        lms_count_courses_val = "0"
        for lms_count_courses in cur:
            lms_count_courses_val = lms_count_courses[0]
        conn.commit()
        qry_add_update_setting = ""

        if (int(mycommon.tryInt(lms_count_courses_val)) <= 0):
            print(" ### le partenaire  "+str(my_partner['nom'])+" n'as pas de config dans la 'settings_current' il faut en créer ")
            qry_add_update_setting = " INSERT INTO settings_current  " \
                              "SET variable = 'stylesheets',  subkey = 'textfield', title = 'vchamilo',  " \
                              "category = 'stylesheets', selected_value = '"+str(new_theme_name)+"'," \
                                                                                             " access_url = '"+str(lms_virtualhost_id)+"', access_url_changeable = '1', " \
                                                                                                                                       "access_url_locked = '0'; "
            print(" ### qry_add_setting = ", qry_add_update_setting)
        else:
            print(" ### le partenaire  " + str(
                my_partner['nom']) + " A DEJA  de config dans la 'settings_current' il faut faire un UPDATE ")
            qry_add_update_setting = " UPDATE settings_current SET   selected_value = '"+str(new_theme_name)+"'  WHERE access_url = '"+str(lms_virtualhost_id)+"'" \
                                                                                                               " AND variable='stylesheets' " \
                                                                                                               " AND category='stylesheets' ;"
            print(" ### qry_add_setting = ", qry_add_update_setting)

        try:

            cur.execute(qry_add_update_setting)

        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de configurer le theme / logo du  LMS " + str({e}))
            return False, "Impossible de configurer le theme / logo du  LMS " + str({e}),

        conn.commit()

        return True, " Le theme "+str(theme_name)+" a été bien ajouté au partenaire "+str(my_partner['nom'])+" "

    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 configurer le theme / logo du  LMS "



"""
Fonction qui permet de dupliquer les repertoires pour le themes
process : 
1 - supprimer le repertoire concerné s'il existe
2 - dupliquer le repertoire
"""
def Duplicate_LMS_Theme_Design(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', 'original_theme_name', 'new_theme_name']
        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, Creation virtualhost annulée")
                return False, " Les informations fournies sont incorrecte",

        '''
        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', 'original_theme_name', 'new_theme_name']
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
                return False, " Les informations fournies sont incorrecte",

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

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

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


        if (len(original_theme_name) > MYSY_GV.DIRECTORY_MAX_LENGTH or len(new_theme_name)  > MYSY_GV.DIRECTORY_MAX_LENGTH):
            mycommon.myprint(
                str(inspect.stack()[0][
                        3]) + " - Les valeurs '" + original_theme_name + "' ou '" + new_theme_name + "' ont une taille > au max : "+str(MYSY_GV.DIRECTORY_MAX_LENGTH))
            return False, " Les valeurs '" + original_theme_name + "' ou '" + new_theme_name + "' ont une taille > au max : "+str(MYSY_GV.DIRECTORY_MAX_LENGTH)


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

        # initialize the SSH client
        client = paramiko.SSHClient()
        # add to known hosts
        client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
        try:
            client.connect(hostname=MYSY_GV.MYSY_FTP_HOST, username=MYSY_GV.MYSY_FTP_LOGIN, password=MYSY_GV.MYSY_FTP_PWD)
        except:
            print(" ### [!] Cannot connect to the SSH Server")
            return False, " Impossible de dupliquer le theme "

        commands = [
            "rm -rf "+str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"web/css/themes/"+str(new_theme_name),
            "rm -rf "+str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"app/Resources/public/css/themes/"+str(new_theme_name),
            "cp -rf "+str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"web/css/themes/"+str(original_theme_name)+" "+str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"web/css/themes/"+str(new_theme_name),
            "cp -rf "+str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"app/Resources/public/css/themes/"+str(original_theme_name)+"  "+str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"app/Resources/public/css/themes/"+str(new_theme_name),
        ]

        print(" ### Les commandes à executé pr dupliquer ", commands)

        # execute the commands
        for command in commands:
            print("=" * 25, command, "=" * 25)
            stdin, stdout, stderr = client.exec_command(command)
            print(stdout.read().decode())
            err = stderr.read().decode()
            if err:
                print(err)

        print(" ###  OKK Connection to the SSH Server")
        client.close()

        """
        Mise à jour du compte du partenaire avec le nom du theme.
        le champ : lms_theme_name  
        """
        new_data_theme = {}
        new_data_theme['lms_theme_name'] = str(new_theme_name).strip()

        ret_val = MYSY_GV.dbname['partnair_account'].find_one_and_update({'recid': str(partner_recid), 'active': '1'},
                                            {"$set": new_data_theme},
                                                   upsert=False,
                                                    return_document=ReturnDocument.AFTER
                                            )


        return True, " Le theme a été correctement dupliqué"

    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 dupliquer le theme "


"""
Cette fonction permet de récupérer et mettre à jour le fichier du logo 
"""
def Lms_Add_Logo_File(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']
        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, mise à jour logo lms annulée")
                return False, " Les informations fournies sont incorrecte",

        '''
        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',]
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
                return False, " Les informations fournies sont incorrecte",

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



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

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, str(inspect.stack()[0][
                                  3]) + "  - impossible de récupérer les données du partenaire",

        lms_theme_name = ""
        if ("lms_theme_name" in my_partner.keys()):
            if my_partner['lms_theme_name']:
                lms_theme_name = my_partner['lms_theme_name']

        if( lms_theme_name == ""):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Ce partenaire n'a pas de theme associé")
            return False, str(inspect.stack()[0][
                                  3]) + "  - Ce partenaire n'a pas de theme associé"


        status, saved_file = mycommon.Upload_Save_IMG_PNG_File(file, Folder)
        if (status == False):
            return False, "Impossible de récupérer le fichier de configuration de l'image"



        """
        A present que le fichier est recuperé, on va deplacer vers le serveur LMS
        Dans le repertoire : MYSY_GV.MYSY_LMS_BASE_DIRECTORY/str(theme_name)
        """
        cnopts = pysftp.CnOpts()
        cnopts.hostkeys = None
        with pysftp.Connection(host=MYSY_GV.MYSY_FTP_HOST, username=MYSY_GV.MYSY_FTP_LOGIN,
                               password=MYSY_GV.MYSY_FTP_PWD, cnopts=cnopts) as session:
            print("Connection successfully established ... ")
            localFilePath = saved_file
            remoteFilePath = str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"web/css/themes/"+str(lms_theme_name)+"/images/header-logo.png"

            print(" ### DEPLACEMENT DE " + str(localFilePath) + " VERS " + str(remoteFilePath) + " AVANTTT TRAITEMENT")
            # Use put method to upload a file
            session.put(localFilePath, remoteFilePath)
            # Switch to a remote directory
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " DEPLACEMENT DE " + str(localFilePath) + " VERS " + str(
                    remoteFilePath) + " EST OKKKK")

        return True, " Le logo a été correctement mis à 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 le logo "



"""
Cette fonction permet de récupérer et mettre à jour le fichier du background 
"""
def Lms_Add_BG_File(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']
        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, mise à jour logo lms annulée")
                return False, " Les informations fournies sont incorrecte",

        '''
        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',]
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
                return False, " Les informations fournies sont incorrecte",

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


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

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, str(inspect.stack()[0][
                                  3]) + "  - impossible de récupérer les données du partenaire",

        lms_theme_name = ""
        if ("lms_theme_name" in my_partner.keys()):
            if my_partner['lms_theme_name']:
                lms_theme_name = my_partner['lms_theme_name']

        if( lms_theme_name == ""):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Ce partenaire n'a pas de theme associé")
            return False, str(inspect.stack()[0][
                                  3]) + "  - Ce partenaire n'a pas de theme associé"


        status, saved_file = mycommon.Upload_Save_IMG_PNG_File(file, Folder)
        if (status == False):
            return False, "Impossible de récupérer le fichier de configuration de l'image"


        """
        A present que le fichier est recuperé, on va deplacer vers le serveur LMS
        Dans le repertoire : MYSY_GV.MYSY_LMS_BASE_DIRECTORY/str(theme_name)
        """
        cnopts = pysftp.CnOpts()
        cnopts.hostkeys = None
        with pysftp.Connection(host=MYSY_GV.MYSY_FTP_HOST, username=MYSY_GV.MYSY_FTP_LOGIN,
                               password=MYSY_GV.MYSY_FTP_PWD, cnopts=cnopts) as session:
            print("Connection successfully established ... ")
            localFilePath = saved_file
            remoteFilePath = str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"web/css/themes/"+str(lms_theme_name)+"/images/background.png"

            print(" ### DEPLACEMENT DE " + str(localFilePath) + " VERS " + str(remoteFilePath) + " AVANTTT TRAITEMENT")
            # Use put method to upload a file
            session.put(localFilePath, remoteFilePath)
            # Switch to a remote directory
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " DEPLACEMENT DE " + str(localFilePath) + " VERS " + str(
                    remoteFilePath) + " EST OKKKK")

        return True, " Le logo a été correctement mis à 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 le logo "


"""
Cette fonction permet de créer et/ou publier une formation en partant depuis du LMS vers le Search

Algorithme :
Etape 1 :
Depuis le lms, un bouton qui appelle le webservice en passant en argument 
- user.mysy_recid : ceci correspond au recid dans le moteur de recherche
- le code de la formation, pour faire le lien et update plus tard.

Etape 2 :
Dans mysy search (moteur), on se connecte dans le lms, pour collecter les infos et les dupliquer et publier dans mysy search

Etape 3 : 
Une fois la formation créer et/ou publier, mettre l'url (mysy search) dans la table 'course' de mysy lms.
Ceci permettra de mettre un bouton de visualisation dans mysy lms.

Etape 4 : 
Apres la creation de la formation, on crée la session associée. car dans le cadre du LMS, une formation = 1 session (moteur)

"""
def Create_Class_From_Lms(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 = ['lms_mysy_recid', 'lms_class_code', 'lms_class_id', 'lms_class_domaine']
        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, mise à jour logo lms annulée")
                return False, " Les informations fournies sont incorrecte",

        '''
        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 = ['lms_mysy_recid', 'lms_class_code', 'lms_class_id']
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
                return False, " Les informations fournies sont incorrecte",

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

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

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

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


        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(lms_mysy_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            #return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du partenaire",


        """
        Recuperation des données de la formation dans le LMS 
        """
        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )

        cur = conn.cursor()
        cur2 = conn.cursor()
        myquery = "SELECT a.title, a.content, b.code, b.title, b.internal_url, b.full_internal_url  FROM c_course_description as a left join course as b ON a.c_id = b.id  WHERE c_id= '"+ str(lms_class_id)+"' "

        print(" ### myquery = ", myquery)
        cur.execute(myquery)
        """
        /!\: Important : 
        Dans mysy lms, l'utilisateur crée un titre, puis une description. ex : "objectif": "detail de l'objectif" ou "méthode":"detail de la
        de la méthode", etc.
        Pour gérer les fautes de frappe dans l'identification des titres, on va utiliser le calcul de distance de Levenshtein 
        """

        # La liste des champs necessaires à la creation d'une formation dans moteur de recherche
        field_list = ['description', 'trainer', 'institut_formation' 'plus_produit', 'mots_cle',
                      'objectif', 'programme', 'prerequis', 'pourqui']

        new_diction = {}
        local_class_code = ""
        local_class_title = ""
        local_class_internal_url = ""

        nb_courses_info = 0

        for courses_info in cur:
            pave_title_tab = str(courses_info[0]).split(" ")
            for local_val in pave_title_tab:
                nb_courses_info = nb_courses_info +1

                if( lev('description',str(local_val).lower() ) <= 2 ):
                    new_diction['description'] = courses_info[1]

                if (lev('objectif', str(local_val).lower()) <= 2):
                    new_diction['objectif'] = courses_info[1]

                if (lev('prerequis', str(local_val).lower()) <= 2):
                    new_diction['prerequis'] = courses_info[1]

                if (lev('pourqui', str(local_val).lower()) <= 2):
                    new_diction['pourqui'] = courses_info[1]

                if (lev('programme', str(local_val).lower()) <= 2):
                    new_diction['programme'] = courses_info[1]

                if (lev('cles', str(local_val).lower()) <= 2):
                    new_diction['mots_cle'] = courses_info[1]

                if (lev('comparatif', str(local_val).lower()) <= 2):
                    new_diction['plus_produit'] = courses_info[1]



                local_class_code = courses_info[2]
                local_class_title = courses_info[3]
                local_class_internal_url = courses_info[4]

        if( nb_courses_info == 0 ):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - La formation n'a pas tous les champs necessaires pour etre publiée dans le moteur de recherche. "
                                                          "Vous devez saisir : description, objectif, programme, prerequis, pourqui")
            return False, str(inspect.stack()[0][3]) + "  - La formation n'a pas tous les champs necessaires pour etre publiée dans le moteur de recherche.\n " \
                                                       " Vous devez saisir : description, objectif, programme, prerequis, pourqui ",

        if(local_class_code ):
            new_diction['external_code'] = local_class_code

        if (local_class_title):
            new_diction['title'] = local_class_title

        new_diction['distantiel'] = "1"
        new_diction['presentiel'] = "0"
        new_diction['published'] = "1"
        new_diction['certif'] = "0"
        new_diction['cpf'] = "0"
        new_diction['note'] = "4"
        new_diction['price'] = "0"
        new_diction['duration_unit'] = "user_rythme"
        new_diction['duration'] = "0"

        if( lms_class_domaine ):
            new_diction['domaine'] = lms_class_domaine

        class_internal_url = ""

        if (local_class_internal_url):
            new_diction['internal_url'] = local_class_internal_url
        else:
            local_status, class_internal_url = mycommon.CreateInternalUrl(local_class_title)
            if( local_status is False ):
                mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de generer le class_internal_url")
                return False, str(inspect.stack()[0][3]) + "  - impossible de generer le class_internal_url",

            new_diction['internal_url'] = class_internal_url

        if ("token" in my_partner.keys()):
            if my_partner['token']:
                new_diction['token'] = my_partner['token']

        if ("nom" in my_partner.keys()):
            if my_partner['nom']:
                new_diction['trainer'] = my_partner['nom']

        new_diction['source'] = "mysy_lms"
        print(" ### new_diction = ", new_diction)


        """
        Avant d'importer la formation, on va s'assurer que les données champs obligatoire sont renseignés
        """
        field_list_obligatoire_formation = ['external_code', 'title', 'description', 'trainer', 'distantiel', 'presentiel',
                                  'token']
        for local_val_ftion in field_list_obligatoire_formation:
            if local_val_ftion not in new_diction.keys():
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + "  - impossible de créer la formation dans le moteur de recherche :" \
                                                 " Le champ '"+local_val_ftion+"' n'existe pas.")
                return False, str(
                    inspect.stack()[0][3]) + "  - impossible de créer la formation dans le moteur de recherche :" \
                                                 " Le champ '"+local_val_ftion+"' n'existe pas.",


        local_status, local_retval = class_mgt.add_class(new_diction)

        if (local_status is False):
            return local_status, local_retval

        """
        Mettre à jour la table 'course' avec la valeur du 'full_internal_url 
        """
        local_class_internal_url_full = str(MYSY_GV.CLIENT_URL_BASE)+str("Display-Detail-formation/")+str(new_diction['internal_url'])

        my_query_local_class_internal_url = "UPDATE course SET full_internal_url = '" + str(local_class_internal_url_full) + "' , mysy_search_published = '1'," \
                                                                                                                             " internal_url = '" + str(new_diction['internal_url']) + "' " \
                                                                                                                             " WHERE id= '"+ str(lms_class_id)+"' "
        print(" ### my_query_local_class_internal_url = ", my_query_local_class_internal_url)

        try:
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur2.execute(my_query_local_class_internal_url)
            conn.commit()
            print(" ### cur2.execute record(s) affected = ", cur2.rowcount)
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de mettre à jours la table cours avec le class_internal_url " + str({e}))
            return False, "Impossible de mettre à jour le class_internal_url" + str({e})

        conn.close()

        """
        Creation de la session de formation associé à la formation.
        Pr memo il s'agit d'une formation 'à la demande' par defaut
        """
        new_diction_session = {}

        new_diction_session['date_debut'] = str(datetime.today().strftime("%d/%m/%Y %H:%M:%S"))
        new_diction_session['date_fin'] = str(datetime.today().strftime("%d/%m/%Y %H:%M:%S"))
        new_diction_session['date_debut_inscription'] = str(datetime.today().strftime("%d/%m/%Y %H:%M:%S"))
        new_diction_session['date_fin_inscription'] = str(datetime.today().strftime("%d/%m/%Y %H:%M:%S"))


        new_diction_session['nb_participant'] = "99"
        new_diction_session['distantiel'] = "1"
        new_diction_session['presentiel'] = "0"

        new_diction_session['session_ondemande'] = "1"
        new_diction_session['prix_session'] = "0"
        new_diction_session['session_status'] = "true"

        new_diction_session['adresse'] = "-"
        new_diction_session['code_postal'] = "-"
        new_diction_session['ville'] = "-"


        if ("token" in my_partner.keys()):
            if my_partner['token']:
                new_diction_session['token'] = my_partner['token']

        if ("nom" in my_partner.keys()):
            if my_partner['nom']:
                new_diction_session['formateur'] = my_partner['nom']

        if (local_class_code):
            new_diction_session['code_session'] = local_class_code
            new_diction_session['formation_session_id'] = local_class_code
            new_diction_session['lms_class_code'] = local_class_code

        if (local_class_internal_url):
            new_diction_session['class_internal_url'] = local_class_internal_url
        else:
            new_diction_session['class_internal_url'] = class_internal_url


        print(" ### new_diction_session = ", new_diction_session)
        local_status, local_retval = Session_Formation.Add_Update_SessionFormation(new_diction_session)
        if (local_status is False):
            return local_status, local_retval

        # Pour finir, on ajoute  'lms_class_code' à la formation dans la collection myclass.
        MYSY_GV.dbname['myclass'].find_one_and_update({'internal_url':str(new_diction_session['class_internal_url']), 'valide':'1', 'locked':'0'},

                                                      {"$set": {'lms_class_code':str(local_class_code)}, 'date_update':str(datetime.now())},
                                                      upsert=False,
                                                      return_document=ReturnDocument.AFTER
                                                      )

        return True, " La formation a bien été créée/mise à jour dans le moteur de recherche"

    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 formation dans le moteur de recherche "


"""
Cette fonction met à jour une formation de MySy-LMS vers MySy-Search
Dans ce cas de figure, tous les champs ne sont 'updatable'
Ne seront pris/mis à jour que les champs reellement saisi dans le LMS (ex : description, objectif, etc)

"""
def Update_Class_From_Lms(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 = ['lms_mysy_recid', 'lms_class_code', 'lms_class_id', 'lms_class_domaine']
        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, mise à jour logo lms annulée")
                return False, " Les informations fournies sont incorrecte",

        '''
        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 = ['lms_mysy_recid', 'lms_class_code', 'lms_class_id']
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
                return False, " Les informations fournies sont incorrecte",

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

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

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

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

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(lms_mysy_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            #return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du partenaire",


        """
        Recuperation des données de la formation dans le LMS 
        """
        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )

        cur = conn.cursor()
        cur2 = conn.cursor()
        myquery = "SELECT a.title, a.content, b.code, b.title, b.internal_url, b.full_internal_url  FROM c_course_description as a left join course as b ON a.c_id = b.id  WHERE c_id= '"+ str(lms_class_id)+"' "

        print(" ### myquery = ", myquery)
        cur.execute(myquery)
        """
        /!\: Important : 
        Dans mysy lms, l'utilisateur crée un titre, puis une description. ex : "objectif": "detail de l'objectif" ou "méthode":"detail de la
        de la méthode", etc.
        Pour gérer les fautes de frappe dans l'identification des titre, on va utiliser le calcul de distance de Levenshtein 
        """

        # La liste des champs necessaires à la creation d'une formation dans moteur de recherche
        field_list = ['description', 'trainer', 'institut_formation' 'plus_produit', 'mots_cle',
                      'objectif', 'programme', 'prerequis', 'pourqui']

        new_diction = {}
        local_class_code = ""
        local_class_title = ""
        local_class_internal_url = ""

        for courses_info in cur:
            pave_title_tab = str(courses_info[0]).split(" ")
            for local_val in pave_title_tab:

                if( lev('description',str(local_val).lower() ) <= 2 ):
                    new_diction['description'] = courses_info[1]

                if (lev('objectif', str(local_val).lower()) <= 2):
                    new_diction['objectif'] = courses_info[1]

                if (lev('programme', str(local_val).lower()) <= 2):
                    new_diction['programme'] = courses_info[1]

                if (lev('prerequis', str(local_val).lower()) <= 2):
                    new_diction['prerequis'] = courses_info[1]

                if (lev('pourqui', str(local_val).lower()) <= 2):
                    new_diction['pourqui'] = courses_info[1]

                if (lev('programme', str(local_val).lower()) <= 2):
                    new_diction['programme'] = courses_info[1]

                if (lev('cles', str(local_val).lower()) <= 2):
                    new_diction['mots_cle'] = courses_info[1]

                if (lev('comparatif', str(local_val).lower()) <= 2):
                    new_diction['plus_produit'] = courses_info[1]



                local_class_code = courses_info[2]
                local_class_title = courses_info[3]
                local_class_internal_url = courses_info[4]

        if(local_class_code ):
            new_diction['external_code'] = local_class_code

        if (local_class_title):
            new_diction['title'] = local_class_title

        new_diction['distantiel'] = "1"
        new_diction['presentiel'] = "0"
        new_diction['published'] = "1"

        if (lms_class_domaine):
            new_diction['domaine'] = lms_class_domaine

        class_internal_url = ""

        if (not local_class_internal_url):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de faire la mise à jour. Pas de valeur pour 'local_class_internal_url' ")
            return False, str(inspect.stack()[0][3]) + "  - impossible de faire la mise à jour. Pas de valeur pour 'local_class_internal_url' ",

        new_diction['internal_url'] = local_class_internal_url

        if ("token" in my_partner.keys()):
            if my_partner['token']:
                new_diction['token'] = my_partner['token']

        if ("nom" in my_partner.keys()):
            if my_partner['nom']:
                new_diction['trainer'] = my_partner['nom']

        print(" ### new_diction = ", new_diction)


        """
        Avant de mettre à jour la formation, on va s'assurer que les données champs obligatoire sont renseignés
        """
        field_list_obligatoire_formation = ['external_code', 'title', 'description', 'trainer', 'distantiel', 'presentiel',
                                  'token']
        for local_val_ftion in field_list_obligatoire_formation:
            if local_val_ftion not in new_diction.keys():
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + "  - impossible de créer la formation dans le moteur de recherche :" \
                                                 " Le champ '"+local_val_ftion+"' n'existe pas.")
                return False, str(
                    inspect.stack()[0][3]) + "  - impossible de créer la formation dans le moteur de recherche :" \
                                                 " Le champ '"+local_val_ftion+"' n'existe pas.",


        local_status, local_retval = class_mgt.update_class(new_diction)

        if (local_status is False):
            return local_status, local_retval


        return True, " La formation a bien été créée/mise à jour dans le moteur de recherche"

    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 formation dans le moteur de recherche "

"""
Cette fonction permet de depublier une formation du LMS dans le Search
"""
def Unpublish_Class_From_Lms(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 = ['lms_mysy_recid', 'lms_class_code', 'lms_class_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, mise à jour logo lms annulée")
                return False, " Les informations fournies sont incorrecte",

        '''
        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 = ['lms_mysy_recid', 'lms_class_code','lms_class_id']
        for val in field_list_obligatoire:
            if val not in diction:
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - La valeur '" + val + "' n'est pas presente dans liste ")
                return False, " Les informations fournies sont incorrecte",

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

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

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

        # Recuperation des données du partenaire
        local_status, my_partner = mycommon.get_partner_data_from_recid(lms_mysy_recid)
        if (local_status is False):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            #return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du partenaire",

        mydata = {}
        mydata['date_update'] = str(datetime.now())
        mydata['published'] = '0'

        ret_val = MYSY_GV.dbname['myclass'].update_many(
            {'external_code': str(lms_class_code),  'locked': '0',
             'valide': '1'}, {"$set": mydata}, )

        if( not ret_val or ret_val is None ):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - Impossible de depubliée la formation au code =" + str(lms_class_code))
            return True, " Impossbile de depublier la formation au code" + str(lms_class_code) + " "

        """
               Recuperation des données de la formation dans le LMS 
               """
        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )

        cur = conn.cursor()

        my_query_local_class_internal_url = "UPDATE course SET  mysy_search_published = '0'  WHERE id = '"+ str(lms_class_id)+"' "
        print(" ### my_query_local_class_internal_url = ", my_query_local_class_internal_url)


        try:
            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query_local_class_internal_url)
            conn.commit()
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de deplublier la formation  " + str({e}))
            return False, "Impossible de deplublier la formation " + str({e})

        conn.close()

        return True, " La formation " + str(lms_class_code) + "a été depublié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 mettre à jour la formation dans le moteur de recherche "



"""
Cette fonction permet de créer et mettre à jour une formation dans le MySy LMS
/!\ : Depuis MySy Search, on a un tag qui dit "pushed_lms", "date_pushed_lms", "date_updated_pushed_lms"
Si le champ "pushed_lms" est à "1" alors la formation, alors la formation deja ete poussé, c'est une mise à jour à faire.

Liste des controle : 
1 - Verifier que le code_formation n'existe pas sur un scope global
2 - Verifier qu'une formation avec le meme titre n'existe pas, sur un scope du partenaire.
3 - Apres la creation de la formation dans MySy LMS, stocker le l'id de la formation dans MySy Search
4 - Pousser les mise à jours sur les champs : "description", "pourqui", etc..

"""
def Push_Class_To_MySy_LMS(diction):
    try:

        diction = mycommon.strip_dictionary(diction)

        """
        Verification des input acceptés
        """
        field_list = ['token', "class_internal_url",]

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

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



        local_status, my_partner = mycommon.Check_Connexion_And_Return_Partner_Data(diction)
        if( local_status is not True):
            return local_status, my_partner


        """
        Connexion à la base de données du LMS
        """
        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()

        # Recuperation des codes de formation qui exite dans le LMS
        query = "select title, code from  course  "
        print(" ### query = ", query)
        cur.execute(query)

        for cours_title_and_code in cur:
            print(" ### cours  = ", cours_title_and_code)


        """
        Verifier que le user qui poste la formation  ( my_partner['mysy_lms_user_id']) 
        existe et qu'il a bien le droit dans le LMS
        """

        mysy_lms_user_id = ""
        if ("mysy_lms_user_id"  in  my_partner.keys()):
            if( my_partner['mysy_lms_user_id']):
                mysy_lms_user_id = my_partner['mysy_lms_user_id']

        if( str(mysy_lms_user_id) == ""):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - Vous n'avez pas les droits nécessaires pour publier une formation dans le LMS ")
            return False, " - Vous n'avez pas les droits nécessaires pour publier une formation dans le LMS ",

        query = "select count(*), user_id  from  user where user_id = '"+str(mysy_lms_user_id)+"' and active = '1' and enabled = '1' and locked = '0' and expired = '0' "
        print(" ### query  user where user_id = ", query)
        cur.execute(query)

        lms_user_info_data = {}
        for query_compte_exist_exec in cur:
            query_compte_exist_exec_val = query_compte_exist_exec[0]
            if (int(mycommon.tryInt(query_compte_exist_exec_val)) != 1):
                mycommon.myprint(
                    str(inspect.stack()[0][
                            3]) + " - Vous n'avez pas les droits nécessaires pour publier une formation dans le LMS (2)")
                return False, " - Vous n'avez pas les droits nécessaires pour publier une formation dans le LMS (2) ",

            lms_user_info_data['user_id'] = query_compte_exist_exec[1]

        """
        Recuperation des champs de MySy Search (collection : myclass)
         : title, description, objectif, prerequis, pourqui, programme, plus_produit
        """
        Class_To_Push = MYSY_GV.dbname['myclass'].find_one({'internal_url':str(diction['class_internal_url']),
                                                            'valide':'1', 'locked':'0'})
        if( Class_To_Push is None ):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - La formation '" + str(diction['class_internal_url']) + "' n'est pas valide ")
            return False, "- La formation '" + str(diction['class_internal_url']) + "' n'est pas valide ",


        # Verifier que les champs obligatoires pour la creation dans le LMS sont bien presents dans le Search
        champ_oblig_pr_publication = ['description', 'objectif', 'prerequis', 'pourqui', 'programme', 'plus_produit']
        for local_val in champ_oblig_pr_publication:
            if( local_val not in Class_To_Push.keys() ):
                mycommon.myprint(
                    str(inspect.stack()[0][3]) + " - Le champ "+str(local_val)+" de la  formation '" + str(diction['class_internal_url']) + "' n'est pas valide ")
                return False, " - Le champ "+str(local_val)+" de la  formation '" + str(diction['class_internal_url']) + "' n'est pas valide ",


        update_push = False

        # Verifier si la formation a un code 'LMS', au quel cas, on fait des mises à jour coté LMS
        # On doit s'assurer que le champ 'lms_class_code' est bien ou contient une valeur qui semble un minimum pertinente
        # d'ou le fait de s'assurer que le contenu fait plus de 2 caractères
        lms_class_code = ""
        if ("lms_class_code" in Class_To_Push.keys()):
            lms_class_code = Class_To_Push['lms_class_code']
            if(len(str(lms_class_code).strip()) > 2):
                update_push = True


        # Si le lms_class_code est vide, alors cette formation n'a jamais ete pushé dans le LMS, on le créé le code
        if( str(lms_class_code) == ""):
            lms_class_code= mycommon.create_user_recid()[0:10]

        data_to_push = {}
        data_to_push['lms_class_code'] = lms_class_code
        data_to_push['title'] = Class_To_Push['title']
        data_to_push['description'] = Class_To_Push['description']
        data_to_push['objectif'] = Class_To_Push['objectif']
        data_to_push['prerequis'] = Class_To_Push['prerequis']
        data_to_push['pourqui'] = Class_To_Push['pourqui']
        data_to_push['programme'] = Class_To_Push['programme']
        data_to_push['mots_cle'] = Class_To_Push['mots_cle']
        data_to_push['internal_url'] = Class_To_Push['internal_url']
        data_to_push['plus_produit'] = Class_To_Push['plus_produit']
        data_to_push['mysy_lms_user_id'] = my_partner['mysy_lms_user_id']
        data_to_push['lms_virtualhost_id'] = my_partner['lms_virtualhost_id']
        data_to_push['mysy_search_published'] = Class_To_Push['published']
        data_to_push['partner_owner_recid'] = Class_To_Push['partner_owner_recid']
        data_to_push['full_internal_url'] =  str(MYSY_GV.CLIENT_URL_BASE) + str("Display-Detail-formation/") + str(Class_To_Push['internal_url'])

        print(" ### " + str(inspect.stack()[0][3]) + " - lms_class_code = ", lms_class_code)
        print(" ### " + str(inspect.stack()[0][3]) + " - update_push = ", update_push)


        query_insert_class = ""
        if( update_push is False):
            # C'est une insertion qu'il faut faire
            print(" ### on fait un push initial")
            query_insert_class =  "INSERT INTO course SET code='"+str( data_to_push['lms_class_code'] )+"' ,  " \
                                                                        "visibility='2'," \
																		 "title = '"+str(data_to_push['title'])+"', " \
                                                                        "mysy_search_published = '" + str(data_to_push['mysy_search_published']) + "', " \
                                                                        "directory = '"+str( data_to_push['lms_class_code'] )+"',  " \
																		 "course_language = 'french', " \
																		  "disk_quota = '100000000', " \
																		  "full_internal_url = '"+str(data_to_push['full_internal_url'])+"', " \
                                                                           "subscribe = '1', " \
                                                                           "description='" + str( data_to_push['title']) + "',  " \
																		  "creation_date ='" + str(datetime.now().strftime("%Y-%m-%d %H:%M:%S")) + "',  " \
																		 "internal_url = '"+str(data_to_push['internal_url'])+"'," \
																		 " visual_code = '"+str( data_to_push['lms_class_code'] )+"';" \

        else:
            mycommon.myprint(" La mise à jour n'est pas autorisée. lms_class_code " + str(lms_class_code))
            return False, " La mise à jour n'est pas autorisée. "

        print(" #### query_insert_class = ", query_insert_class)
        try:
            cur.execute(query_insert_class)


        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer la formation dans le LMS " + str({e}))
            return False, " Impossible de créer la formation dans le LMS " + str({e})

        conn.commit()
        print(" #### Last Inserted ID = ", cur.lastrowid)
        new_class_id = str(cur.lastrowid)


        query_access_url_rel_course = " INSERT INTO access_url_rel_course (c_id,access_url_id) VALUES ('"+str(new_class_id)+"', '1') , ('"+str(new_class_id)+"', '"+ str( data_to_push['lms_virtualhost_id'])  +"') "
        print(" #### query_access_url_rel_course = ", query_access_url_rel_course)
        try:
            cur.execute(query_access_url_rel_course)

        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer la formation dans le LMS  (1)" + str({e}))
            return False, " Impossible de créer la formation dans le LMS (1) " + str({e})

        conn.commit()


        query_course_rel_user = "insert into course_rel_user set user_id='"+ str( data_to_push['mysy_lms_user_id']) +"', c_id='" +str(new_class_id)+ "' , relation_type = '0', status = '1', is_tutor = '0', sort = '1' "

        print(" #### query_course_rel_user = ", query_course_rel_user)
        try:
            cur.execute(query_course_rel_user)

        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer la formation dans le LMS  (2)" + str({e}))
            return False, " Impossible de créer la formation dans le LMS (2) " + str({e})

        conn.commit()


        """ 
        Recuperation du dernier iid de la table c_document
        """
        query_max_c_document = " SELECT max(iid) FROM c_document  "

        cur.execute(query_max_c_document)
        max_c_document_id = ""
        for query_max_c_document_val in cur:
            max_c_document_id = query_max_c_document_val[0]

        if (int(mycommon.tryInt(max_c_document_id)) <=  0 ):
                mycommon.myprint(
                    str(inspect.stack()[0][
                            3]) + " - Vous n'avez pas les droits nécessaires pour publier une formation dans le LMS (3)")
                return False, " - Vous n'avez pas les droits nécessaires pour publier une formation dans le LMS (3) ",

        max_c_document_id_int = int(mycommon.tryInt(max_c_document_id)) + 1
        query_insert_c_document = "  INSERT INTO c_document (id,c_id,`path`,comment,title,filetype,`size`,readonly,session_id) " \
                                  " VALUES  " \
                                  " ('"+str(max_c_document_id_int)+"', '"+ str(new_class_id) +"' ,'/shared_folder',NULL,'Répertoires des utilisateurs','folder',0,0,0),  " \
                                  " ('"+str(max_c_document_id_int)+"', '"+ str(new_class_id) +"' ,'/chat_files',NULL,'Historique de conversations dans le chat','folder',0,0,0), " \
                                  " ('"+str(max_c_document_id_int)+"', '"+ str(new_class_id) +"' ,'/certificates',NULL,'Certificats','folder',0,0,0); "

        print(" #### query_insert_c_document = ", query_insert_c_document)
        try:
            cur.execute(query_insert_c_document)

        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer la formation dans le LMS  (4)" + str({e}))
            return False, " Impossible de créer la formation dans le LMS (4) " + str({e})

        conn.commit()

        """
        Insertion dans la table : c_course_setting 
        """
        query_insert_course_setting = " INSERT INTO c_course_setting (id,c_id,variable,subkey,`type`,category,value,title,comment,subkeytext) VALUES  " \
            " (1, '"+ str(new_class_id) +"', 'email_alert_manager_on_new_doc',NULL,NULL,'work','0','',NULL,NULL),  " \
            " (2, '"+ str(new_class_id) +"', 'email_alert_on_new_doc_dropbox',NULL,NULL,'dropbox','0','',NULL,NULL), " \
            " (3, '"+ str(new_class_id) +"', 'allow_user_edit_agenda',NULL,NULL,'agenda','0','',NULL,NULL),  " \
            " (4, '"+ str(new_class_id) +"', 'allow_user_edit_announcement',NULL,NULL,'announcement','0','',NULL,NULL), " \
            " (5, '"+ str(new_class_id) +"', 'email_alert_manager_on_new_quiz',NULL,NULL,'quiz','1','',NULL,NULL), " \
            " (6, '"+ str(new_class_id) +"', 'allow_user_image_forum',NULL,NULL,'forum','1','',NULL,NULL), " \
            " (7, '"+ str(new_class_id) +"', 'course_theme',NULL,NULL,'theme','','',NULL,NULL), " \
            " (8, '"+ str(new_class_id) +"', 'allow_learning_path_theme',NULL,NULL,'theme','1','',NULL,NULL), " \
            " (9, '"+ str(new_class_id) +"', 'allow_open_chat_window',NULL,NULL,'chat','1','',NULL,NULL), " \
            " (10, '"+ str(new_class_id) +"', 'email_alert_to_teacher_on_new_user_in_course',NULL,NULL,'registration','0','',NULL,NULL), " \
            " (11, '"+ str(new_class_id) +"',  'allow_user_view_user_list', NULL, NULL, 'user', '1', '', NULL, NULL)," \
            " (12, '"+ str(new_class_id) +"',  'display_info_advance_inside_homecourse', NULL, NULL, 'thematic_advance', '1', '', NULL, NULL)," \
            " (13, '"+ str(new_class_id) +"',  'email_alert_students_on_new_homework', NULL, NULL, 'work', '0', '', NULL, NULL)," \
            " (14, '"+ str(new_class_id) +"',  'enable_lp_auto_launch', NULL, NULL, 'learning_path', '0', '', NULL, NULL)," \
            " (15, '"+ str(new_class_id) +"',  'enable_exercise_auto_launch', NULL, NULL, 'exercise', '0', '', NULL, NULL)," \
            " (16, '"+ str(new_class_id) +"',  'enable_document_auto_launch', NULL, NULL, 'document', '0', '', NULL, NULL)," \
            " (17, '"+ str(new_class_id) +"',  'pdf_export_watermark_text', NULL, NULL, 'learning_path', '', '', NULL, NULL)," \
            " (18, '"+ str(new_class_id) +"',  'allow_public_certificates', NULL, NULL, 'certificates', '', '', NULL, NULL)," \
            " (19, '"+ str(new_class_id) +"',  'documents_default_visibility', NULL, NULL, 'document', 'visible', '', NULL, NULL)," \
            " (20, '"+ str(new_class_id) +"',  'show_course_in_user_language', NULL, NULL, '', '2', '', NULL, NULL), " \
            " (21, '"+ str(new_class_id) +"',  'email_to_teachers_on_new_work_feedback', NULL, NULL, '', '1', '', NULL, NULL)," \
            " (22, '"+ str(new_class_id) +"',  'email_alert_teachers_new_post', NULL, NULL, 'portfolio', '1', '', NULL, NULL)," \
            " (23, '"+ str(new_class_id) +"',  'email_alert_teachers_student_new_comment', NULL, NULL, 'portfolio', '1', '', NULL, NULL)," \
            " (24, '"+ str(new_class_id) +"',  'agenda_share_events_in_sessions', NULL, NULL, 'agenda', '0', '', NULL, NULL)," \
            " (NULL, '"+ str(new_class_id) +"',  'courselegal', 'courselegal', 'text', 'plugins', '', '', NULL, NULL)," \
            " (NULL, '"+ str(new_class_id) +"',  'customcertificate_course_enable', 'customcertificate', 'checkbox', 'plugins', '', '', NULL, NULL)," \
            " (NULL, '"+ str(new_class_id) +"',  'use_certificate_default', 'customcertificate', 'checkbox', 'plugins', '', '', NULL, NULL);"

        print(" #### query_insert_course_setting = ", query_insert_course_setting)
        try:
            cur.execute(query_insert_course_setting)

        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer la formation dans le LMS  (5)" + str({e}))
            return False, " Impossible de créer la formation dans le LMS (5) " + str({e})

        conn.commit()

        """
        Insert dans la table : c_tool
        """
        query_insert_c_tool = " INSERT INTO c_tool (id,c_id,name,link,image,visibility,admin,address,added_tool,target,category,session_id,description,custom_icon) VALUES " \
         " (1, '"+ str(new_class_id) +"', 'course_description','course_description/index.php','info.gif',1,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL), " \
         " (2, '"+ str(new_class_id) +"', 'calendar_event','calendar/agenda.php','agenda.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
         " (3, '"+ str(new_class_id) +"', 'document','document/document.php','folder_document.gif',1,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL), " \
         " (4, '"+ str(new_class_id) +"', 'learnpath','lp/lp_controller.php','scorms.gif',1,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL), " \
         " (5, '"+ str(new_class_id) +"', 'link','link/link.php','links.gif',1,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL), " \
         " (6, '"+ str(new_class_id) +"', 'quiz','exercise/exercise.php','quiz.gif',1,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL), " \
         " (7, '"+ str(new_class_id) +"', 'announcement','announcements/announcements.php','valves.gif',1,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL), " \
         " (8, '"+ str(new_class_id) +"', 'forum','forum/index.php','forum.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
         " (9, '"+ str(new_class_id) +"', 'dropbox','dropbox/index.php','dropbox.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
         " (10, '"+ str(new_class_id) +"', 'user','user/user.php','members.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
        " (11, '"+ str(new_class_id) +"', 'group','group/group.php','group.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
	    " (12, '"+ str(new_class_id) +"', 'chat','chat/chat.php','chat.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
         " (13, '"+ str(new_class_id) +"', 'student_publication','work/work.php','works.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
         " (14, '"+ str(new_class_id) +"', 'survey','survey/survey_list.php','survey.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
         " (15, '"+ str(new_class_id) +"', 'wiki','wiki/index.php','wiki.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
         " (16, '"+ str(new_class_id) +"', 'gradebook','gradebook/index.php','gradebook.gif',1,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL), " \
         " (17, '"+ str(new_class_id) +"', 'glossary','glossary/index.php','glossary.gif',1,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL), " \
         " (18, '"+ str(new_class_id) +"', 'notebook','notebook/index.php','notebook.gif',1,'0','squaregrey.gif',0,'_self','interaction',0,NULL,NULL), " \
         " (19, '"+ str(new_class_id) +"', 'attendance','attendance/index.php','attendance.gif',0,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL), " \
         " (20, '"+ str(new_class_id) +"', 'course_progress','course_progress/index.php','course_progress.gif',0,'0','squaregrey.gif',0,'_self','authoring',0,NULL,NULL) ," \
         " (24, '"+ str(new_class_id) +"', 'blog_management','blog/blog_admin.php','blog_admin.gif',0,'1','squaregrey.gif',0,'_self','admin',0,NULL,NULL),  " \
         " (25, '"+ str(new_class_id) +"', 'tracking','tracking/courseLog.php','statistics.gif',0,'1','',0,'_self','admin',0,NULL,NULL), " \
         " (26, '"+ str(new_class_id) +"', 'course_setting','course_info/infocours.php','reference.gif',0,'1','',0,'_self','admin',0,NULL,NULL), " \
         " (27, '"+ str(new_class_id) +"', 'course_maintenance','course_info/maintenance.php','backup.gif',0,'1','',0,'_self','admin',0,NULL,NULL), " \
         " (106, '"+ str(new_class_id) +"', 'courselegal','courselegal/start.php','courselegal.png',1,'0','squaregrey.gif',0,'_self','plugin',0,NULL,NULL), " \
         " (107, '"+ str(new_class_id) +"', 'customcertificate','customcertificate/start.php','customcertificate.png',0,'0','squaregrey.gif',0,'_self','plugin',0,NULL,NULL), " \
         " (108, '"+ str(new_class_id) +"', 'google_meet','google_meet/start.php','google_meet.png',1,'0','squaregrey.gif',0,'_self','plugin',0,NULL,NULL); "



        print(" #### query_insert_c_tool = ", query_insert_c_tool)
        try:
            cur.execute(query_insert_c_tool)

        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer la formation dans le LMS  (6)" + str({e}))
            return False, " Impossible de créer la formation dans le LMS (6) " + str({e})

        conn.commit()

        # Si la publication se passe bien alors, on met à jour la collection MyClass avec le statut et la date.

        data_update = {}
        data_update['lms_class_code'] = lms_class_code
        data_update['date_update'] = str(datetime.now())

        data_cle = {}
        data_cle['internal_url'] = str(Class_To_Push['internal_url'])
        data_cle['partner_owner_recid'] = str(Class_To_Push['partner_owner_recid'])
        data_cle['valide'] = "1"
        data_cle['locked'] = "0"

        print(" #### data_cle 11 = ", data_cle)


        local_ret_val = MYSY_GV.dbname['myclass'].find_one_and_update(data_cle,
                                                                      {"$set": data_update},
                                                                      upsert=False,
                                                                      return_document=ReturnDocument.AFTER
                                                                      )

        if( local_ret_val is None or "_id" not in  local_ret_val.keys() ):
            mycommon.myprint(
                " WARNING : Impossible de mettre à jour le partner_account avec Le champ lms_class_code = "+str( lms_class_code) )

        """
        A présent que la formation est correctement poussée dans le LMS, on va mettre à jour les champs : ['description', 'objectif', 'prerequis', 'pourqui', 'programme', 'plus_produit']
        """

        """ 
           Recuperation du dernier iid de la table c_course_description
           """
        query_max_c_course_description = " SELECT max(iid) FROM c_course_description  "

        cur.execute(query_max_c_course_description)
        max_c_course_description_id = ""
        for query_max_c_course_description_val in cur:
            max_c_course_description_id = query_max_c_course_description_val[0]

        if (int(mycommon.tryInt(max_c_course_description_id)) <= 0):
            mycommon.myprint(
                " WARNING : Impossible de récupérer le max_c_course_description_id ")



        qry_insert_c_course_description = 	"INSERT INTO c_course_description (id,c_id,title,content,session_id,description_type,progress) VALUES " \
                     "('"+str(int(mycommon.tryInt(max_c_course_description_id)) + 1)+"','"+ str(new_class_id)+"','Description','"+mycommon.Clean_For_SQL( str(data_to_push['description']) )+"',0,1,0), " \
                     "('"+str(int(mycommon.tryInt(max_c_course_description_id)) + 2)+"','"+ str(new_class_id)+"','Objectif','"+mycommon.Clean_For_SQL(str(data_to_push['objectif']))+"',0,8,0), " \
                     "('"+str(int(mycommon.tryInt(max_c_course_description_id)) + 4)+"','"+ str(new_class_id)+"','Programme','"+mycommon.Clean_For_SQL(str(data_to_push['programme']))+"',0,8,0), " \
                     "('"+str(int(mycommon.tryInt(max_c_course_description_id)) + 6)+"','"+ str(new_class_id)+"','Pourqui','"+mycommon.Clean_For_SQL(str(data_to_push['pourqui']))+"',0,8,0), " \
                     "('"+str(int(mycommon.tryInt(max_c_course_description_id)) + 7)+"','"+ str(new_class_id)+"','Mots clés','"+mycommon.Clean_For_SQL(str(data_to_push['mots_cle']))+"',0,8,0), " \
                     "('"+str(int(mycommon.tryInt(max_c_course_description_id)) + 8)+"','"+ str(new_class_id)+"','Avantage comparatif','"+mycommon.Clean_For_SQL(str(data_to_push['plus_produit']))+"',0,8,0); "

        print(" ### qry_insert_c_course_description = ", qry_insert_c_course_description)
        try:
            cur.execute(qry_insert_c_course_description)

        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer la formation dans le LMS  (6)" + str({e}))
            return False, " Impossible de créer la formation dans le LMS (6) " + str({e})

        conn.commit()

        return True, " La formation " + str(lms_class_code) + "a été correctement Ajoutée/Mise à jour sur la plateforme de E-Learning"

    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 formation sur la plateforme de E-Learning "



"""
Cette fonction permet de créer proprement
un enseignant rattaché à un compte partenaire
"""
def Create_MySy_LMS_Enseignant_Account(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', 'lastname', 'firstname', 'email', 'password', 'locked', 'official_code', 'username', 'rh_partner_account_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 autorisé", False

        '''
        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', 'lastname', 'firstname', 'email', 'password', 'locked', 'official_code', 'rh_partner_account_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, " Toutes les informations obligatoire n'ont pas été fournies", False

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_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, False

        partner_recid = str(my_partner['recid'])

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_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, False

        partner_recid = str(my_partner['recid'])


        lastname = ""
        if ("lastname" in diction.keys()):
            if diction['lastname']:
                local_status, lastname = mycommon.RemoveAllNonAlphaNumeric(diction['lastname'])

        firstname = ""
        if ("firstname" in diction.keys()):
            if diction['firstname']:
                local_status, firstname = mycommon.RemoveAllNonAlphaNumeric(diction['firstname'])

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

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

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

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

        username = ""
        if ("username" in diction.keys()):
            if diction['username']:
                local_status, username = mycommon.RemoveAllNonAlphaNumeric(diction['username'])

        # Recuperation des données du partenaire
        local_status, my_partner_data = mycommon.get_partner_data_from_recid(partner_recid)
        if (local_status is False):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - impossible de récupérer les données du partenaire")
            return False, str(inspect.stack()[0][3]) + "  - impossible de récupérer les données du partenaire", False

        # On affecte le lms_virtualhost_id par defaut à la racine, donc le site principale.
        # Si le propritaire de la formation à un 'lms_virtualhost_id' dédié, on remplace le principale par celui du proprio
        lms_virtualhost_id = "1"
        if ("lms_virtualhost_id" in my_partner_data.keys()):
            if my_partner_data['lms_virtualhost_id']:
                lms_virtualhost_id = my_partner_data['lms_virtualhost_id']

        nom_partner = ""
        if ("nom" not in my_partner_data.keys()):
            mycommon.myprint(str(inspect.stack()[0][3]) + " - Le nom du partenaire est vide ")
            return False, str(inspect.stack()[0][3]) + "  -  Le nom du partenaire est vide "

        nom_partner = mycommon.remove_non_ascii(str(my_partner_data['nom']))

        local_status, nom_partner = mycommon.local_Remove_Ponct_Special_Caractere(nom_partner)
        if (local_status is False):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - Le nom du partenaire : local_Remove_Ponct_Special_Caractere ")
            return False, str(
                inspect.stack()[0][3]) + "  -  Le nom du partenaire : local_Remove_Ponct_Special_Caractere ", False

        suffix_nom_partner = str(nom_partner)[0:3]

        username = str(str(username) + "_" + str(suffix_nom_partner)).lower()
        local_status, username = mycommon.RemoveAllNonAlphaNumeric(unidecode(username))
        if (local_status is False):
            mycommon.myprint(
                str(inspect.stack()[0][3]) + " - erreur  : RemoveAllNonAlphaNumeric ")
            return False, str(
                inspect.stack()[0][3]) + "  -  erreur : RemoveAllNonAlphaNumeric ", False

        # print(" ### username = ",username)
        registration_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

        mysy_sequence_id = ""

        # Rcuperation de la sequence de l'objet "lms_user_id" dans la collection : "mysy_sequence"
        retval = MYSY_GV.dbname['mysy_sequence'].find_one({'related_mysy_object': 'lms_user_id', 'valide': '1',
                                                           'partner_owner_recid':str(my_partner['recid'])})

        if (retval is None or "current_val" not in retval.keys()):

            # Il n'a pas de sequence pour ce partenaire, verifier s'il ya une sequence par defaut
            retval = MYSY_GV.dbname['mysy_sequence'].find_one({'related_mysy_object': 'lms_user_id', 'valide': '1',
                                                               'partner_owner_recid': "default"})

            if (retval is None or "current_val" not in retval.keys()):
                mycommon.myprint(" Aucune séquence 'lms_user_id' n'est paramétré dans le système ")
                return False, " Aucune séquence 'lms_user_id' n'est paramétré dans le système ", False

        # on stock l'id trouvé
        mysy_sequence_id = str(retval['_id'])


        new_lms_user_id = str(retval['prefixe']) + str(retval['current_val'])



        local_status, local_val = mycommon.IsInt(new_lms_user_id)
        if (local_status is False):
            mycommon.myprint(" Impossible de generer l'ID du user LMS. La valeur actuelle est ", new_lms_user_id)
            return False, " Impossible de generer l'ID du user LMS", False


        current_seq_value = str(retval['current_val'])

        mypasswd = password.encode('UTF-8')

        salt = bcrypt.gensalt()
        hashed_pwd = bcrypt.hashpw(mypasswd, salt)

        if (type(salt) is bytes):
            salt = salt.decode("UTF-8")
            hashed_pwd = hashed_pwd.decode("UTF-8")

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()

        # Verification d'abord si le compte exite.
        query_compte_exist = " Select count(*), user_id From  user WHERE username = '" + username + "' "
        print(" ### query_compte_exist = ", query_compte_exist)
        query_compte_exist_exec = cur.execute(query_compte_exist)



        query_compte_exist_exec = ""
        query_compte_exist_exec_val = "0"
        for query_compte_exist_exec in cur:
            query_compte_exist_exec_val = query_compte_exist_exec[0]
            if (int(mycommon.tryInt(query_compte_exist_exec_val)) > 0):
                new_lms_user_id = query_compte_exist_exec[1]
        conn.commit()


        if( int(mycommon.tryInt(query_compte_exist_exec_val)) > 0  ):
            # Le compte existe, il faut donc faire une mise à jour
            my_query = "UPDATE user SET salt = '" + str(salt) + "', credentials_expired='0', " \
                                                                "updated_at='" + str(registration_date) + " ',  " \
                                                                                                          "password = '" + str(
                hashed_pwd) + "', " \
                              "enabled='1', " \
                              "expired='0',  " \
                              "mysy_recid='"+str(diction['rh_partner_account_id'])+"',  " \
                               "mysy_partner_owner_recid='" + str(my_partner['recid']) + "',  " \
                              "mysy_partner_owner_lms_user_id='" + str( my_partner['mysy_lms_user_id']) + "',  " \
                                       "locked = '0', " \
                              "auth_source = 'platform'," \
                              "roles = 'a:0:{}', " \
                              "language = 'french'," \
                              "username_canonical = '" + username + "', " \
                                                                    " email_canonical = '" + email + "', " \
                                                                                                     "email = '" + email + "'," \
                                                                                                                           " official_code	= '" + official_code + "', " \
                                                                                                                                                                     "active = '1' WHERE  username='" + str(
                email) + "' ;"
        else:
            # Le compte n'existe pas, il faut le créer


            # insert information
            my_query = "INSERT INTO user SET id='"+str(new_lms_user_id)+"' ,  " \
                                                                        "user_id='"+str(new_lms_user_id)+"' , " \
                                                                                                         "lastname = '"+lastname+"', " \
                                                                                                         "firstname = '"+firstname+"',  " \
                                                                                                         "username = '"+username+"', " \
                                                                                                       "mysy_recid='"+str(diction['rh_partner_account_id'])+"',  " \
                                                                                                        "mysy_partner_owner_recid='" + str(my_partner['recid']) + "',  " \
                                                                                                                                                                  "mysy_partner_owner_lms_user_id='" + str(
                my_partner['mysy_lms_user_id']) + "',  " \
                                                  " salt = '"+str(salt)+"'," \
                                                                                                         " registration_date = '"+registration_date+"'," \
                                                                                                         " credentials_expired='0', " \
                                                                                                         "enabled='1', " \
                                                                                                         "expired='0',  " \
                                                                                                         "created_at='" + str( registration_date) + "'," \
                                                                                                                                                                                               "  updated_at='" + str( registration_date) + "', " \
                                                                                                                                                                                                                                            " status = '1', " \
                                                                                                         "password = '"+str(hashed_pwd)+"', " \
                                                                                                         "locked = '0', " \
                                                                                                         "username_canonical = '"+username+"', " \
                                                                                                         " email_canonical = '"+email+"', " \
                                                                                                         "email = '"+email+"'," \
                                                                                                         " official_code	= '"+official_code+"', " \
                                                                                                         "creator_id  = '1', " \
                                                                                                         "auth_source = 'platform'," \
                                                                                                         "roles = 'a:0:{}', " \
                                                                                                         "language = 'french'," \
                                                                                                         "active = '1';"

        try:
            print(" ### my_query aaa = ", my_query)
            #cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query)
        except mariadb.Error as e:
            #print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'enseignant LMS "+str({e}))
            return False, "Impossible de créer l'enseignant LMS "+str({e}), False

        conn.commit()

        lastrowid = cur.lastrowid

        my_query_access_url_rel_user = "INSERT INTO access_url_rel_user SET access_url_id='" + str(lms_virtualhost_id) + "' ,  user_id='" + str(new_lms_user_id) + "'  "
        print(" ### my_query_access_url_rel_user = ", my_query_access_url_rel_user)
        try:

            # cur.execute("INSERT INTO employees (first_name,last_name) VALUES (?, ?)", ("Maria", "DB"))
            cur.execute(my_query_access_url_rel_user)
        except mariadb.Error as e:
            # print(f"Error: {e}")
            mycommon.myprint(str(inspect.stack()[0][3]) + " WARNING - impossible d'ajouter le user '" + str(
                new_lms_user_id) + "'  à la table access_url_rel_user pour la recheche et l'envoi des email")

        conn.commit()

        conn.close()
        # InCrementation de la sequence de l'objet "lms_user_id" dans la collection : "mysy_sequence"

        print(" ### current_seq_value = ", current_seq_value)
        new_sequence_value = int(mycommon.tryInt(current_seq_value)) + 1
        print(" ### new_sequence_value = ", new_sequence_value)

        mydata = {'current_val': new_sequence_value}
        ret_val2 = MYSY_GV.dbname['mysy_sequence'].find_one_and_update(
            {'_id':ObjectId(mysy_sequence_id)},
            {"$set": mydata},
            return_document=ReturnDocument.AFTER,
            upsert=False,
            )

        return True, " Creation du compte Enseignant LMS OK. l'id = " + str(new_lms_user_id), str(new_lms_user_id)



    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 le compte enseignant dans le LMS", False


"""
Cette fonction permet de desactivier le compte d'un utilisateur (enseignant ou 
 apprenant) dans MySy-LMS
"""
def Disable_MySy_LMS_Account(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', 'rh_id_to_disable']

        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 autorisé"

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

        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, " Toutes les informations obligatoire n'ont pas été fournies"

        # recuperation des paramettre
        my_token = ""
        if ("token" in diction.keys()):
            if diction['token']:
                my_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, False


        is_valide_acount_data = MYSY_GV.dbname['ressource_humaine'].find_one({'_id':ObjectId(str(diction['rh_id_to_disable'])),
                                                                              'valide':'1',
                                                                              'partner_recid':str(my_partner['recid'])})

        if( is_valide_acount_data is None):
            mycommon.myprint(str(inspect.stack()[0][3]) + " L'identifiant du compte à désactiver est invalide  ")
            return False, " L'identifiant du compte à désactiver est invalide  "

        account_partner_id = ""
        if( "account_partner_id" not in is_valide_acount_data.keys() ):
            mycommon.myprint(str(inspect.stack()[0][3]) + " L'identifiant du compte à désactiver est invalide (2) ")
            return False, " L'identifiant du compte à désactiver est invalide (2) "

        account_to_disable_data = MYSY_GV.dbname['partnair_account'].find_one({'_id':ObjectId(str(is_valide_acount_data['account_partner_id'])),
                                                                               'recid':str(my_partner['recid'])})

        if( account_to_disable_data is None or "mysy_lms_user_id" not in account_to_disable_data.keys() ):
            mycommon.myprint(str(inspect.stack()[0][3]) + " L'identifiant du compte à désactiver est invalide (3) ")
            return False, " L'identifiant du compte à désactiver est invalide (3) "

        conn = mariadb.connect(
            user=MYSY_GV.MYSY_MARIADB_USER,
            password=MYSY_GV.MYSY_MARIADB_USER_PASS,
            host=MYSY_GV.MYSY_MARIADB_HOST,
            port=MYSY_GV.MYSY_MARIADB_PORT,
            database=MYSY_GV.MYSY_LMS_BDD
        )
        cur = conn.cursor()
        registration_date = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
        my_query = "UPDATE user SET  locked='1' , updated_at='" + str(registration_date) + " ',   WHERE  user_id='" + str(account_to_disable_data['mysy_lms_user_id']) + "' and mysy_partner_owner_recid = '"+ str(my_partner['recid']) +"' ;"

        try:
            print(" ### my_query aaa = ", my_query)

            cur.execute(my_query)
        except mariadb.Error as e:
            #print(f"Error: {e}")
            mycommon.myprint(" Impossible de créer l'enseignant LMS "+str({e}))
            return False, "Impossible de créer l'enseignant LMS "+str({e})

        conn.commit()
        conn.close()

        update_account = {}
        update_account['date_update'] = str(datetime.now().strftime("%d/%m/%Y %H:%M:%S"))
        update_account['update_by'] = str(my_partner['_id'])
        update_account['lms_account_disable'] = "1"

        # Mettre à jour le compte dans mysy-search pour dire que le compte lms est desactivé
        MYSY_GV.dbname['partnair_account'].find_one_and_update({'mysy_lms_user_id':str(account_to_disable_data['mysy_lms_user_id']),
                                                                'recid':str(my_partner['recid'])},
                                                               {'$set':update_account})

        return True, " Le compte a été correctement désactivé"

    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 désactiver le compte "
