def addUser():
if request.method == 'POST':
# Recuperation + traitement des données du formulaire
data = Utils.parseForm(dict(request.form))
# Cryptage des mots des passe + Decryptage des id
data["password"] = Crypt.encode(cfg._APP_SECRET_KEY, data["password"])
data["id"] = Crypt.decode(cfg._APP_SECRET_KEY, data["id"])
mdl = AuthUsersModel(cfg._BDD_PATH)
# Verification
if mdl.is_unique_username(data["username"]) is False:
return Render.jsonTemplate(
_OPERATION,
"Un utilisateur avec cet identifiant existe déjà",
categorie="WARNING")
# Traitement en BDD
try:
mdl.insertUser(data)
except SqliteAdapterException as errorSQL:
return Render.jsonTemplate(
_OPERATION,
'Ajout Utilisateur Impossible : {}'.format(str(errorSQL)),
categorie="ERROR")
else:
return Render.jsonTemplate(_OPERATION,
'Ajout Utilisateur',
categorie="SUCCESS")
else:
abort(400)
def marketsEdit(idCrypt):
# Recuperation des ressources statiques Bokeh
js_resources = INLINE.render_js()
css_resources = INLINE.render_css()
# Creation de la Strategie
stgyObj = StgyFactory("DEV").make()
# Decryptage id
idDecrypt = Crypt.decode(cfg._APP_SECRET_KEY, idCrypt)
# Recuperation des infos
data = MarketsModel().getMarketById(idDecrypt).to_dict('Records')
# Recuperation des prix
stgyObj.run(symbol=data[0]['symbol'], ut='H1')
# Recuperation des Ordres
df_orders = OrdersModel().getOrdersBySymbol(symbol=data[0]['symbol'])
# Construction du Graphique avec Ordres
graph = stgyObj.plot()
graph.addOrders(df_orders)
script, div = components(graph.save())
# Preparation des données de la page
data = {
'id': idCrypt,
# Graphique
'plot_div': div,
'plot_script': script,
'js_resources': js_resources,
'css_resources': css_resources
}
# Renvoi de la page
return Render.htmlTemplate('home/marketEdit.html', data=data)
def getUsers():
"""Recuperation des Utilisateurs"""
if request.method == 'POST':
# Recuperation des infos
df = AuthUsersModel().getAllUsers()
# Decryptage des mots des passe
df["password"] = df.apply(
lambda x: Crypt.decode(cfg._APP_SECRET_KEY, x['password']), axis=1)
# Cryptage des id
df["id"] = df.apply(
lambda x: Crypt.encode(cfg._APP_SECRET_KEY, x['id']), axis=1)
# Renvoi de la reponse JSON
return Render.jsonTemplate(_OPERATION,
'Liste des Utilisateurs',
categorie="SUCCESS",
data=df.to_dict('Records'))
else:
abort(400)
def updateUser():
if request.method == 'POST':
# Recuperation + traitement des données du formulaire
data = Utils.parseForm(dict(request.form))
data["password"] = Crypt.encode(cfg._APP_SECRET_KEY, data["password"])
data["id"] = Crypt.decode(cfg._APP_SECRET_KEY, data["id"])
# Traitement en BDD
mdl = AuthUsersModel(cfg._BDD_PATH)
try:
mdl.updateUser(data)
except SqliteAdapterException as errorSQL:
return Render.jsonTemplate(
_OPERATION,
'Modification Utilisateur Impossible : {}'.format(
str(errorSQL)),
categorie="ERROR")
else:
return Render.jsonTemplate(_OPERATION,
'Modification Utilisateur',
categorie="SUCCESS")
else:
abort(400)
def updateById():
if request.method == 'POST':
# Recuperation + traitement des données du formulaire
data = Utils.parseForm(dict(request.form))
# Decryptage id
data["id"] = Crypt.decode(cfg._APP_SECRET_KEY, data["id"])
# Recuperation des infos
MarketsModel().update(data)
# Retour du message
return Render.jsonTemplate(_OPERATION,
'Changement du Statut',
categorie="SUCCESS")
else:
abort(400)
def getAll():
"""Parse un fichier de log dans un DataFrame"""
if request.method == 'POST':
# Recuperation des infos
data = MarketsModel().getAll()
# Cryptage des id
data["id"] = data.apply(
lambda x: Crypt.encode(cfg._APP_SECRET_KEY, x['id']), axis=1)
# Retour du message
return Render.jsonTemplate(_OPERATION,
'Marchés',
categorie="SUCCESS",
data=data.to_dict("records"))
else:
abort(400)
def checkUser(username=None, password=None, ip=None):
"""
Verifie la cohérenece login/password de l'utilisateur
Si OK, alors creation de la Session
"""
# Verification USERNAME
if username is None:
raise AppException("[AUTH] - Aucune Identifiant à verifier")
# Verification PASSWORD
if password is None:
raise AppException("[AUTH] - Aucune Password à verifier")
# Initialisation du Modele
mdl = AuthUsersModel()
# Recuperation des informations utilisateurs
user = mdl.getUserByUsername(username)
# Si l'utilisateur n'existe pas
if user is None:
return False
# Mot de passe Incorrecte
# if (user["password"] != Crypt.encode(cfg._APP_SECRET_KEY, password)):
if (user["password"] != Crypt.encode(cfg._APP_SECRET_KEY, password)):
# Si non valide, incrémenter le nombre de connexions ayant échoué
mdlFailedLogon = AuthFailedLoginModel()
mdlFailedLogon.incrementFailedLogins(
username, mdlFailedLogon.getFailedLoginByUser(username), ip)
# Egalement, vérifiez si l'adresse IP actuelle tente de se connecter à l'aide de plusieurs comptes,
# Si c'est le cas, alors bloquez-le, sinon, ajoutez simplement un nouvel enregistrement à la base de données
# TODO
mdlFailedLogon.handleIpFailedLogin(ip, username)
del mdlFailedLogon
return False
# Si le login est ok
# Init Session
idSession = uuid.uuid1()
Session.setValue("id", idSession)
Session.setValue("is_logged_in", True)
Session.setValue("username", user["username"])
Session.setValue("role", user["role"])
Session.setValue("displayName", user["display"])
# Enregistrement de last_connect + id de Session en bdd
mdl.updateLastConn(username)
mdl.updateIdSession(username, idSession)
# Remise a zero des tentatives echoués
AuthFailedLoginModel().resetFailedLogins(username)
return True
def getMarketById():
if request.method == 'POST':
# Recuperation + traitement des données du formulaire
data = Utils.parseForm(dict(request.form))
# Decryptage id
idDecrypt = Crypt.decode(cfg._APP_SECRET_KEY, data["id"])
# Recuperation des infos
df = MarketsModel().getMarketById(idDecrypt)
data = {}
data["info"] = {}
data["info"] = df.to_dict("Records")
# Retour du message
return Render.jsonTemplate(_OPERATION,
'Marchés',
categorie="SUCCESS",
data=data)
else:
abort(400)
def __init__(self):
# Recuperation du path du fichier
filename = cfg._BDD_PATH
# Initialisation objet parent
super().__init__(filename)
# Definition de la table
self.table = "mtb_auth_users"
# Creation de la table
if not self.tblExists(table=self.table):
logger.info("Table {} inexistante >> Creation".format(self.table))
query = initial_sql.format(TABLE=self.table)
self.query(query)
# Ajouter utilisateur par default
logger.info("Ajout utilisateur par default")
self.insertUser(
data={
'username': "******",
'password': Crypt.encode(cfg._APP_SECRET_KEY, 'admin'),
'display': "Administrateur",
'role': 'ADMIN',
})
def deleteUser():
if request.method == 'POST':
# Recuperation + traitement des données du formulaire
data = Utils.parseForm(dict(request.form))
# Decryptage id
data["id"] = Crypt.decode(cfg._APP_SECRET_KEY, data["id"])
mdl = AuthUsersModel(cfg._BDD_PATH)
# Verification que la valeur username n'existe pas déjà
try:
mdl.deleteUser(data)
except SqliteAdapterException as errorSQL:
return Render.jsonTemplate(
_OPERATION,
'Suppression Utilisateur Impossible : {}'.format(
str(errorSQL)),
categorie="ERROR")
else:
return Render.jsonTemplate(_OPERATION,
'Suppression Utilisateur',
categorie="SUCCESS")
else:
abort(400)
def deblockUser():
if request.method == 'POST':
# Recuperation + traitement des données du formulaire
data = Utils.parseForm(dict(request.form))
# Decryptage id
data["id"] = Crypt.decode(cfg._APP_SECRET_KEY, data["id"])
# Recuperation utiisateur
mdl = AuthUsersModel()
user = mdl.getUserById(data["id"])
# Execution du deblocage
try:
mdl.resetFailedLogins(user["username"])
except SqliteAdapterException as errorSQL:
return Render.jsonTemplate(
_OPERATION,
'Deblocage Utilisateur Impossible : {}'.format(str(errorSQL)),
categorie="ERROR")
else:
return Render.jsonTemplate(_OPERATION,
'Deblocage Utilisateur',
categorie="SUCCESS")
else:
abort(400)