1826 lines
83 KiB
Python
1826 lines
83 KiB
Python
import pymongo
|
|
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
|
|
import socket
|
|
import smtplib
|
|
import re
|
|
import requests
|
|
# Connexion mariadb sur serveur
|
|
import mariadb
|
|
import hashlib
|
|
import bcrypt
|
|
from pymongo import ReturnDocument
|
|
|
|
|
|
"""
|
|
Cette fonction créer un utilisateur (editeur de formation) 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:
|
|
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']
|
|
|
|
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]) + " - Le token 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 recuperer le token du partenaire")
|
|
return False, " Impossible de recuperer 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
|
|
|
|
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")
|
|
|
|
|
|
# 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 recuperer la sequence 'mysy_sequence' ")
|
|
return False, "Impossible de recuperer 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(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(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 = ", 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}")
|
|
|
|
|
|
""""
|
|
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 recuperer les données du partenaire")
|
|
return False, str(inspect.stack()[0][3]) + " - impossible de recuperer 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 varibblers")
|
|
|
|
lastrowid = cur.lastrowid
|
|
|
|
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({'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:
|
|
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]) + " - Le token 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 recuperer le token du partenaire")
|
|
return False, " Impossible de recuperer 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 créer l'utilisateur LMS " + str({e}))
|
|
return False, "Impossible de créer 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 permet de desactivier les formation 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:
|
|
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]) + " - Le token 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 recuperer le token du partenaire")
|
|
return False, " Impossible de recuperer 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:
|
|
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]) + " - Le token 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 recuperer le token du partenaire")
|
|
return False, " Impossible de recuperer 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 recuperer les données du partenaire")
|
|
return False, str(inspect.stack()[0][3]) +" - impossible de recuperer 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 recuperer les données du pack (1)")
|
|
return False, str(inspect.stack()[0][3]) + " - impossible de recuperer 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 LSM ")
|
|
return False, str(inspect.stack()[0][3]) + " - Impossible de créer le compte LSM "
|
|
|
|
# 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 "
|
|
|
|
# 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 ")
|
|
"""
|
|
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 "
|
|
|
|
|
|
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:
|
|
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]) + " - Le token n'est pas valide")
|
|
return False, False, False, str(inspect.stack()[0][3]) + " - Le token 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 recuperer le token du partenaire")
|
|
return False, False, False, str(inspect.stack()[0][3]) + " - Impossible de recuperer 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 recuperer les données du partenaire")
|
|
return False, False, False, " - impossible de recuperer 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 recuperer 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:
|
|
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]) + " - Le token n'est pas valide")
|
|
return False, str(inspect.stack()[0][3]) + " - Le token 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 recuperer le token du partenaire")
|
|
return False, str(
|
|
inspect.stack()[0][3]) + " - Impossible de recuperer 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 recuperer les données du partenaire")
|
|
return False, " - impossible de recuperer 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 = ", 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:
|
|
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]) + " - Le token n'est pas valide")
|
|
return False, str(inspect.stack()[0][3]) + " - Le token 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 recuperer le token du partenaire")
|
|
return False, str(
|
|
inspect.stack()[0][3]) + " - Impossible de recuperer 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 recuperer les données du partenaire")
|
|
return False, " - impossible de recuperer 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 = ", 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 enseignat """
|
|
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:
|
|
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]) + " - Le token 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 recuperer le token du partenaire")
|
|
return False, " Impossible de recuperer 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
|
|
|
|
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")
|
|
|
|
|
|
# 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 recuperer la sequence 'mysy_sequence' ")
|
|
return False, "Impossible de recuperer 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', " \
|
|
"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 = ", 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()
|
|
|
|
# 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({'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 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
|
|
"""
|
|
|
|
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:
|
|
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']
|
|
|
|
|
|
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 recuperer les données du partenaire")
|
|
return False, str(inspect.stack()[0][3]) + " - impossible de recuperer 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 recuperer les données du pack de service")
|
|
return False, str(inspect.stack()[0][3]) + " - impossible de recuperer 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_url = ""
|
|
if( lms_account == "1"):
|
|
lms_user_id = my_partner['mysy_lms_user_id']
|
|
lms_user_name = my_partner['email']
|
|
lms_pwd_mask = my_partner['pwd']
|
|
lms_part_recid = my_partner['recid']
|
|
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(my_partner['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_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 recuperer les données LMS du partner" |