4603 lines
220 KiB
Python
4603 lines
220 KiB
Python
import base64
|
|
|
|
import pymongo
|
|
import pysftp
|
|
import zeep
|
|
from pymongo import MongoClient
|
|
import json
|
|
from bson import ObjectId
|
|
import re
|
|
from datetime import datetime, date
|
|
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")
|
|
|
|
|
|
#print(" ### CLAIRE PWD = ", password)
|
|
#print(" ### hashed_pwd PWD = ", hashed_pwd)
|
|
|
|
|
|
|
|
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 011 = ", 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_env_api='" + str(MYSY_GV.MYSY_ENV_API) + "', " \
|
|
"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_env_api='" + str(MYSY_GV.MYSY_ENV_API) + "', " \
|
|
"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 1= ", 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')
|
|
|
|
#print(" ### MOT DE PASSE RECU EST : ", newpassword)
|
|
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 PWD LMS = ", 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
|
|
|
|
"""
|
|
"""
|
|
14/04/2025 : desormais les pack ne sont pas liés au nombre de formation
|
|
Donc pour eviter des blocages coté LMS sur le nombre de formation,
|
|
le nombre de formations est tjours = 999
|
|
"""
|
|
|
|
# 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 :
|
|
Lorsque 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', 'session_end_date']
|
|
|
|
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")
|
|
|
|
session_end_date_str = ""
|
|
if( "session_end_date" in diction.keys() and diction['session_end_date']):
|
|
local_status = mycommon.CheckisDate(str(diction['session_end_date'])[0:10])
|
|
if (local_status is False):
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][
|
|
3]) + "La date de fin de session (session_end_date) n'est pas au format jj/mm/aaaa ")
|
|
|
|
return False, "La date de fin de session (session_end_date) n'est pas au format jj/mm/aaaa "
|
|
session_end_date = datetime.strptime(str(diction['session_end_date']), '%d/%m/%Y')
|
|
session_end_date_str = str(session_end_date.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" and 'mysy_lms_user_id' in connected_user_data.keys() ):
|
|
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 retourne le logo et la bannière d'un LMS
|
|
"""
|
|
|
|
def Get_LMS_Logo_And_Bannier_Img(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é"
|
|
|
|
"""
|
|
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)
|
|
"""
|
|
|
|
|
|
|
|
logo_encoded_string = ""
|
|
banniere_encoded_string = ""
|
|
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 ... ")
|
|
|
|
remoteFilePath_logo = str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"web/css/themes/"+str(lms_theme_name)+"/images/header-logo.png"
|
|
|
|
#session.get(remoteFilePath_logo, MYSY_GV.TEMPORARY_DIRECTORY_V2+"header-logo.png")
|
|
|
|
remoteFilePath_banniere = str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY) + "web/css/themes/" + str(
|
|
lms_theme_name) + "/images/background.png"
|
|
|
|
todays_date = str(date.today().strftime("%d/%m/%Y"))
|
|
ts = datetime.now().timestamp()
|
|
ts = str(ts).replace(".", "").replace(",", "")[-5:]
|
|
|
|
local_logo_file = MYSY_GV.TEMPORARY_DIRECTORY_V2+"header-logo_" + str(ts) + ".png"
|
|
local_banniere_file = MYSY_GV.TEMPORARY_DIRECTORY_V2+"background_" + str(ts) + ".png"
|
|
|
|
lms_images = {}
|
|
lms_images['logo'] = ""
|
|
lms_images['banniere'] = ""
|
|
|
|
if( session.isfile(remoteFilePath_logo) ):
|
|
session.get(remoteFilePath_logo, local_logo_file)
|
|
with open(local_logo_file, "rb") as image_file_logo:
|
|
logo_encoded = base64.b64encode(image_file_logo.read())
|
|
logo_base64_encoded_str = logo_encoded.decode()
|
|
lms_images['logo'] = logo_base64_encoded_str
|
|
os.remove(local_logo_file)
|
|
|
|
if (session.isfile(remoteFilePath_banniere)):
|
|
session.get(remoteFilePath_banniere, local_banniere_file)
|
|
with open(local_banniere_file, "rb") as image_file_banniere:
|
|
banniere_encoded = base64.b64encode(image_file_banniere.read())
|
|
banniere_base64_encoded_str = banniere_encoded.decode()
|
|
lms_images['banniere'] = banniere_base64_encoded_str
|
|
os.remove(local_banniere_file)
|
|
|
|
RetObject = []
|
|
RetObject.append(mycommon.JSONEncoder().encode(lms_images))
|
|
|
|
# Suppression des fichier telechargé en local sur le serveur
|
|
|
|
|
|
|
|
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écuperer le logo et la bannière "
|
|
|
|
|
|
|
|
|
|
|
|
"""
|
|
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_Delete_Logo_File(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é"
|
|
|
|
|
|
|
|
|
|
|
|
"""
|
|
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 ... ")
|
|
|
|
remoteFilePath = str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"web/css/themes/"+str(lms_theme_name)+"/images/header-logo.png"
|
|
|
|
print(" ### SUPPRESSION DU FICHIER " + str(remoteFilePath) + " AVANTTT TRAITEMENT")
|
|
# Use put method to upload a file
|
|
session.remove( remoteFilePath)
|
|
|
|
|
|
# Switch to a remote directory
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " SUPPRESSION DU FICHIER DE " + str(remoteFilePath) + " ")
|
|
|
|
return True, " Le logo a été correctement supprimé "
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de supprimer le logo "
|
|
|
|
|
|
|
|
"""
|
|
Cette fonction permet de supprimer la bannière d'un lms
|
|
"""
|
|
def Lms_Delete_Banniere_File(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é"
|
|
|
|
|
|
|
|
|
|
|
|
"""
|
|
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 ... ")
|
|
|
|
remoteFilePath = str(MYSY_GV.MYSY_LMS_BASE_DIRECTORY)+"web/css/themes/"+str(lms_theme_name)+"/images/background.png"
|
|
|
|
print(" ### SUPPRESSION DU FICHIER " + str(remoteFilePath) + " AVANTTT TRAITEMENT")
|
|
# Use put method to upload a file
|
|
session.remove( remoteFilePath)
|
|
|
|
|
|
# Switch to a remote directory
|
|
mycommon.myprint(
|
|
str(inspect.stack()[0][3]) + " SUPPRESSION DU FICHIER DE " + str(remoteFilePath) + " ")
|
|
|
|
return True, " Le logo a été correctement supprimé "
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de supprimer le logo "
|
|
|
|
|
|
|
|
"""
|
|
Cette fonction permet de supprimer le fichier 'logo' d'un theme
|
|
"""
|
|
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, " L'image a été correctement mise à jour"
|
|
|
|
except Exception as e:
|
|
exc_type, exc_obj, exc_tb = sys.exc_info()
|
|
mycommon.myprint(str(inspect.stack()[0][3]) + " -" + str(e) + " - Line : " + str(exc_tb.tb_lineno))
|
|
return False, " Impossible de mettre à jour l'image "
|
|
|
|
|
|
"""
|
|
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']
|
|
|
|
print(" ### lms_mysy_recid = ", 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 à partir du _id
|
|
local_status, my_partner = mycommon.get_partner_data_from_id(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",
|
|
|
|
#print(" ### my_partner ici = ", my_partner)
|
|
|
|
"""
|
|
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
|
|
|
|
if (lms_class_code):
|
|
new_diction['lms_class_code'] = lms_class_code
|
|
|
|
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']
|
|
|
|
|
|
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', '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_id(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]) + " Identifiant du partenaire est invalide ",
|
|
|
|
|
|
"""
|
|
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
|
|
|
|
if (lms_class_code):
|
|
new_diction['lms_class_code'] = lms_class_code
|
|
|
|
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']
|
|
|
|
|
|
#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', '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.",
|
|
|
|
|
|
#print(" #### new_diction = ", new_diction)
|
|
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',
|
|
'partner_owner_recid':str(my_partner['recid'])})
|
|
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)
|
|
|
|
print(" #### data_update 11 = ", data_update)
|
|
|
|
|
|
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'])
|
|
|
|
#print(" #### password recu pour encode = ",password)
|
|
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_env_api='" + str(MYSY_GV.MYSY_ENV_API) + "', " \
|
|
"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_env_api='" + str(
|
|
MYSY_GV.MYSY_ENV_API) + "', " \
|
|
"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 2= ", 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 3= ", 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 "
|