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 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 login():
error = None
if request.method == 'POST':
# Entrée dans les logs
# Recuperation des Parametres Utilisateurs
username = request.form['username']
password = request.form['password']
userIp = request.remote_addr
# [ETAPE 1] - Verification si le user est bloqué par son IP
if Auth.isIpBlocked(ip=userIp):
return Render.htmlTemplate("login.html",
data="Votre IP est bloqué")
# [ETAPE 2] - Vérifier si l'utilisateur a précédemment échoué ses tentatives de connexion
if Auth.getFailedLoginByUser(username=username):
return Render.htmlTemplate(
"login.html",
data=
"Vous avez dépassé le nombre de tentatives possibles, veuillez réessayer plus tard"
)
# [ETAPE 3] - Obtenir l'utilisateur de la base de données
if not Auth.checkUser(username=username, password=password, ip=userIp):
return Render.htmlTemplate(
"login.html",
data=
"Les Informations d'identification sont invalides. Veuillez réessayer."
)
else:
# Redirection vers l'accueil
print("Connexion reussi pour : {}".format(Session.getUserId()))
return redirect(url_for('home.home'))
else:
return Render.htmlTemplate('login.html', data=error)
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 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 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 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 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 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 changelog():
# Ouverture du fichier
readme_file = open(cfg._INIT_DIR + os.sep + "CHANGELOG.md",
"r",
encoding="UTF-8")
# Conversion du Markdown
md_template_string = markdown.markdown(readme_file.read(),
extensions=["fenced_code"])
# Affichage template
return Render.htmlTemplate('home/changelog.html',
data={"markdown": md_template_string})
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 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 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 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)
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 run(user):
# Initialisation des Parametres + Variables
_OPERATION = "Synchronisation des Marchés"
logger.info(
"Lancement de la Synchronisation des Marchés par : {}".format(
user))
SyncMarketsHelpersObj = None
try:
# ========================================================================================
yield Render.sseTemplate(
perc=1,
message="Demarrage de la synchronisation des Marchés",
operation=_OPERATION,
categorie="NORMAL")
SyncMarketsHelpersObj = SyncMarketsHelpers()
# Initialisation du Broker
yield Render.sseTemplate(perc=25,
message="Connexion au Broker",
operation=_OPERATION,
categorie="TITLE")
SyncMarketsHelpersObj.connect()
# Obtenir les Marchés
yield Render.sseTemplate(perc=50,
message="Recuperation des Marchés",
operation=_OPERATION,
categorie="TITLE")
SyncMarketsHelpersObj.getMarkets()
# Mise à jour dela BDD
yield Render.sseTemplate(
perc=75,
message="Mise à jour de la BDD (Traitement Long)",
operation=_OPERATION,
categorie="TITLE")
SyncMarketsHelpersObj.updateBdd()
# Fin de Traitement
SyncMarketsHelpersObj.disconnect()
yield Render.sseTemplate(
perc=100,
message="Fin de Syncronisation des Ordres",
operation=_OPERATION,
categorie="SUCCESS")
except Exception as error:
logger.exception(error)
yield Render.sseTemplate(perc=100,
message=str(error),
operation=_OPERATION,
categorie="ERROR")
finally:
time.sleep(0.2)
def dev():
# Recuperation des ressources statiques Bokeh
js_resources = INLINE.render_js()
css_resources = INLINE.render_css()
# Creation de la Strategie
stgyObj = StgyFactory("DEV").make()
# Recuperation des prix
stgyObj.run(symbol='EURUSD', ut='H1')
# Recuperation des Ordres
df_orders = OrdersModel().getOrdersBySymbol(symbol='EURUSD')
# 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 = {
# Graphique
'plot_div': div,
'plot_script': script,
'js_resources': js_resources,
'css_resources': css_resources
}
return Render.htmlTemplate('dev/dev.html', data=data)
def perf():
return Render.htmlTemplate('home/perf.html')
def orders():
return Render.htmlTemplate('home/orders.html')
def backtest():
return Render.htmlTemplate('home/backtest.html')
def index():
return Render.htmlTemplate('home/index.html')
