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 run():
if request.method == 'POST':
if BOT.active is True:
BOT.stop()
return Render.jsonTemplate(_OPERATION, 'Arret du Bot', categorie="SUCCESS", data=BOT.active)
elif BOT.active is False:
BOT.start()
return Render.jsonTemplate(_OPERATION, 'Demarrage du Bot', categorie="SUCCESS", data=BOT.active)
else:
return Render.jsonTemplate(_OPERATION, '????', categorie="ERROR", data=BOT.active)
else:
abort(400)
def updateParam():
if request.method == 'POST':
# Recuperation + traitement des données du formulaire
data = Utils.parseForm(dict(request.form))
# Initialisation de la Config
config = Configuration.from_filepath()
# Modification de la config
if 'time_zone' in data:
config.set_time_zone(data['time_zone'])
if 'hour_start' in data:
config.set_hour_start(data['hour_start'])
if 'hour_end' in data:
config.set_hour_end(data['hour_end'])
if 'filepathCredentials' in data:
config.set_filepathCredentials(data['filepathCredentials'])
if 'use_demo_account' in data:
config.set_use_demo_account(True if data['use_demo_account'] ==
'true' else False)
if 'spin_interval' in data:
config.set_spin_interval(data['spin_interval'])
# Envoi du message
return Render.jsonTemplate(_OPERATION,
'Enregistrement de la Configuration',
categorie="SUCCESS")
else:
abort(400)
def exceptions(e):
"""
logger = Logger()
logger.pid = Session.getPid()
logger.user = Session.getUserDisplay()
# ----------------------------------------------------
# Trace dans l'activité d'une erreur dans activity.log
logger.error('{APP_NAME} à rencontré une erreur'.format(APP_NAME=cfg._APP_NAME))
# ----------------------------------------------------
# Trace de l'exception dans un fichier à part
# import traceback
# traceback.print_exc()
logger.critical(
nom=exc_type.__name__,
message=str(exc_value),
trace=exc_tb
)
"""
# Recuperation ERREUR et trace dans Activité
exc_type, exc_value, exc_tb = sys.exc_info()
# print(exc_value)
# loggerAct.exception(e)
# Renvoi Erreur
if Utils.isAjaxRequest(request) is True:
return Render.jsonTemplate(
operation='OOPS !! Une erreur est arrivé',
message='{MESSAGE}'.format(MESSAGE=exc_value),
categorie="ERROR",
code=500)
return Render.htmlTemplate("errors/{}.html".format(str(500)),
data=None,
code=500)
def unauthentified(error):
if request.path.startswith("/api/"):
return Render.jsonTemplate(operation='Utilisateur deconnecté',
message='Acces refusé par le serveur',
categorie="ERROR",
code=error.code)
return Render.htmlTemplate("errors/{}.html".format(error.code),
data=None,
code=error.code)
def bad_request(error):
if request.path.startswith("/api/"):
return Render.jsonTemplate(
operation='Mauvaise Requete',
message="La requête n'a pas pu être comprise par le serveur",
categorie="ERROR",
code=error.code)
return Render.htmlTemplate("errors/{}.html".format(error.code),
data=None,
code=error.code)
def unauthorised(error):
if request.path.startswith("/api/"):
return Render.jsonTemplate(
operation='Accés Interdit',
message='Accés interdit à cette fonctionnalité',
categorie="ERROR",
code=error.code)
return Render.htmlTemplate("errors/{}.html".format(error.code),
data=None,
code=error.code)
def incorrect_request(error):
if request.path.startswith("/api/"):
return Render.jsonTemplate(
operation='OOPS !! Une erreur est arrivé',
message='Methode Non Autorisé ou CSRF Incorrecte',
categorie="ERROR",
code=error.code)
return Render.htmlTemplate("errors/{}.html".format(error.code),
data=None,
code=error.code)
def page_not_found_error(error):
if request.path.startswith("/api/"):
return Render.jsonTemplate(operation='Chemin inconnu',
message="L'URL est inconnu : {}".format(
request.path),
categorie="ERROR",
code=error.code)
return Render.htmlTemplate("errors/{}.html".format(error.code),
data=None,
code=error.code)
def getWatcherEntries():
if request.method == 'POST':
# Recuperation des infos
data = LogWatcherModel().getAll()
# Retour du message
return Render.jsonTemplate(_OPERATION,
'Observateur URL',
categorie="SUCCESS",
data=data.to_dict("Record"))
else:
abort(400)
def getActivityEntries():
"""Parse un fichier de log dans un DataFrame"""
if request.method == 'POST':
# Recuperation des infos
data = LogActivityModel().getAll()
# Retour du message
return Render.jsonTemplate(_OPERATION,
'Activité',
categorie="SUCCESS",
data=data.to_dict("Record"))
else:
abort(400)
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 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 getActivityEntries():
"""Parse un fichier de log dans un DataFrame"""
if request.method == 'POST':
# Recuperation des infos
entries = LogBotModel().getAll()
data = {
"entries": entries.to_dict("records"),
'state': BOT.active
}
# Retour du message
return Render.jsonTemplate(_OPERATION, 'Bot', categorie="SUCCESS", data=data)
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)
def getParam():
"""Parse un fichier de log dans un DataFrame"""
if request.method == 'POST':
# Recuperation des infos
data = Configuration.from_filepath().json()
# Cryptage des id
# df["id"] = df.apply(lambda x: Crypt.encode(cfg._APP_SECRET_KEY, x['id']), axis=1)
# Retour du message
return Render.jsonTemplate(_OPERATION,
'Parametres',
categorie="SUCCESS",
data=data)
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 getReport():
"""Parse un fichier de log dans un DataFrame"""
if request.method == 'POST':
# Recuperation + traitement des données du formulaire
data = Utils.parseForm(dict(request.form))
if 'period' not in data:
raise AppException("Le parametre de Periode n'est pas disponible")
if data['period'] not in ('DAILY', 'WEEKLY', 'MONTHLY', 'YEAR'):
raise AppException("Le parametre de Periode n'est pas disponible")
# Recuperation des Ordres
orders = OrdersModel().getAll()
# Init Dahboard
dashObj = DashBoard(orders)
dashObj.init(data['period'])
# Creation du Dict de données du DashBoard
ret = {}
# HEADER
ret['period_detail'] = dashObj.period()
ret['period_start_fmt'] = dashObj.start()
ret['period_end_fmt'] = dashObj.end()
ret['capital_today'] = 0
ret['gp_total'] = dashObj.gp_total()
ret['gp_lose'] = dashObj.gp_lose()
ret['gp_wins'] = dashObj.gp_wins()
# ret['gp_ratio_lose'] = dashObj.gp_ratio_lose(orders)
# ret['gp_ratio_wins'] = dashObj.gp_ratio_wins(orders)
ret['trade_total'] = dashObj.trade_total()
ret['trade_lose'] = dashObj.trade_lose()
ret['trade_wins'] = dashObj.trade_wins()
ret['trade_ratio_lose'] = dashObj.trade_ratio_lose()
ret['trade_ratio_wins'] = dashObj.trade_ratio_wins()
ret['evaluation'] = dashObj.evalu()
# [GRAPH] - Performance des Trades
ret['PerfTradeDataGraph'] = dashObj.getPerfTradeByDay()
ret['PerfGpDataGraph'] = dashObj.getPerfGpByDay()
# Recuperation des infos
# data = OrdersModel().getAll()
# Retour du message
del dashObj
return Render.jsonTemplate(_OPERATION,
'Données Dashboard',
categorie="SUCCESS",
data=ret,
silent=True)
else:
abort(400)
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 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 testJSON():
Session.setPid()
# raise AppException("TESSTTTTT ERRORS.LOG")
return Render.jsonTemplate('TITRE', 'WOOHOO', categorie="INFO", code=200)
def getState():
if request.method == 'POST':
return Render.jsonTemplate(_OPERATION, 'Statut du Bot', categorie="SUCCESS", data=BOT.active, silent=True)
else:
abort(400)