225 lines
7.3 KiB
Python
225 lines
7.3 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
📊 Position Monitor - Trade Exit Detection
|
|
Überwacht offene Positionen und updated die Datenbank wenn sie geschlossen werden
|
|
"""
|
|
|
|
import MetaTrader5 as mt
|
|
from datetime import datetime
|
|
from trading_database import TradingDatabase
|
|
from telegram_notifier import TelegramNotifier
|
|
import logging
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
class PositionMonitor:
|
|
"""
|
|
Überwacht offene Positionen und erkennt wenn sie geschlossen werden
|
|
"""
|
|
|
|
def __init__(self, database: TradingDatabase, telegram: TelegramNotifier = None):
|
|
self.db = database
|
|
self.telegram = telegram
|
|
self.tracked_positions = {} # {ticket: position_data}
|
|
|
|
def check_open_positions(self):
|
|
"""
|
|
Prüft alle offenen Positionen in der Datenbank
|
|
und vergleicht mit MT5 um geschlossene zu finden
|
|
"""
|
|
try:
|
|
# Hole alle offenen Positionen aus der Datenbank
|
|
open_trades = self.db.get_open_trades()
|
|
|
|
if not open_trades:
|
|
return
|
|
|
|
# Hole aktuelle Positionen von MT5
|
|
mt5_positions = mt.positions_get()
|
|
mt5_tickets = {pos.ticket for pos in mt5_positions} if mt5_positions else set()
|
|
|
|
# Prüfe jede offene Position aus der DB
|
|
for trade in open_trades:
|
|
ticket = trade['ticket']
|
|
|
|
# Wenn Position nicht mehr in MT5 → wurde geschlossen
|
|
if ticket not in mt5_tickets:
|
|
self._handle_closed_position(ticket, trade)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error checking positions: {e}")
|
|
|
|
def _handle_closed_position(self, ticket, trade_data):
|
|
"""
|
|
Behandelt eine geschlossene Position
|
|
"""
|
|
try:
|
|
# Hole Trade-History von MT5 (letzten 30 Tage)
|
|
from datetime import timedelta
|
|
now = datetime.now()
|
|
days_ago = now - timedelta(days=30)
|
|
deals = mt.history_deals_get(days_ago, now, ticket=ticket)
|
|
|
|
if not deals:
|
|
logger.warning(f"No history found for ticket {ticket}")
|
|
return
|
|
|
|
# Finde das Close-Deal (letztes Deal für dieses Ticket)
|
|
close_deal = None
|
|
for deal in deals:
|
|
if deal.entry == 1: # Entry out = Close
|
|
close_deal = deal
|
|
break
|
|
|
|
if not close_deal:
|
|
logger.warning(f"No close deal found for ticket {ticket}")
|
|
return
|
|
|
|
# Berechne Exit-Daten
|
|
exit_price = close_deal.price
|
|
exit_time = datetime.fromtimestamp(close_deal.time)
|
|
profit = close_deal.profit
|
|
commission = close_deal.commission
|
|
swap = close_deal.swap
|
|
|
|
# Berechne weitere Metriken
|
|
entry_time = datetime.strptime(trade_data['entry_time'], '%Y-%m-%d %H:%M:%S')
|
|
duration = (exit_time - entry_time).total_seconds() / 3600 # hours
|
|
|
|
net_profit = profit + commission + swap
|
|
|
|
# RR Ratio berechnen (falls SL/TP bekannt)
|
|
rr_ratio = None
|
|
if trade_data.get('sl_price') and trade_data.get('tp_price'):
|
|
entry_price = trade_data['entry_price']
|
|
sl_price = trade_data['sl_price']
|
|
tp_price = trade_data['tp_price']
|
|
|
|
risk = abs(entry_price - sl_price)
|
|
reward = abs(tp_price - entry_price)
|
|
if risk > 0:
|
|
rr_ratio = reward / risk
|
|
|
|
# Bestimme Exit-Grund
|
|
exit_reason = self._determine_exit_reason(
|
|
exit_price,
|
|
trade_data.get('sl_price'),
|
|
trade_data.get('tp_price'),
|
|
trade_data['type']
|
|
)
|
|
|
|
# Update Database
|
|
exit_data = {
|
|
'exit_price': exit_price,
|
|
'exit_time': exit_time.strftime('%Y-%m-%d %H:%M:%S'),
|
|
'duration_hours': duration,
|
|
'profit': profit,
|
|
'commission': commission,
|
|
'swap': swap,
|
|
'net_profit': net_profit,
|
|
'rr_ratio': rr_ratio,
|
|
'status': 'closed',
|
|
'exit_reason': exit_reason
|
|
}
|
|
|
|
self.db.update_trade_exit(ticket, exit_data)
|
|
|
|
logger.info(f"✅ Updated closed position {ticket}: {exit_reason}, Profit: {net_profit:.2f}")
|
|
|
|
# Sende Telegram Notification
|
|
if self.telegram:
|
|
self._send_exit_notification(ticket, trade_data, exit_data)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error handling closed position {ticket}: {e}")
|
|
|
|
def _determine_exit_reason(self, exit_price, sl_price, tp_price, trade_type):
|
|
"""
|
|
Bestimmt warum der Trade geschlossen wurde
|
|
"""
|
|
if not sl_price or not tp_price:
|
|
return "manual_close"
|
|
|
|
tolerance = 0.5 # Pips tolerance
|
|
|
|
if trade_type == "BUY":
|
|
if abs(exit_price - tp_price) <= tolerance:
|
|
return "take_profit"
|
|
elif abs(exit_price - sl_price) <= tolerance:
|
|
return "stop_loss"
|
|
else: # SELL
|
|
if abs(exit_price - tp_price) <= tolerance:
|
|
return "take_profit"
|
|
elif abs(exit_price - sl_price) <= tolerance:
|
|
return "stop_loss"
|
|
|
|
return "manual_close"
|
|
|
|
def _send_exit_notification(self, ticket, trade_data, exit_data):
|
|
"""
|
|
Sendet Telegram Notification für geschlossenen Trade
|
|
"""
|
|
try:
|
|
notification_data = {
|
|
'ticket': ticket,
|
|
'symbol': trade_data['symbol'],
|
|
'type': trade_data['type'],
|
|
'entry_price': trade_data['entry_price'],
|
|
'exit_price': exit_data['exit_price'],
|
|
'exit_time': exit_data['exit_time'],
|
|
'exit_reason': exit_data['exit_reason'],
|
|
'net_profit': exit_data['net_profit'],
|
|
'duration_hours': exit_data['duration_hours'],
|
|
'session': trade_data.get('session', 'unknown')
|
|
}
|
|
|
|
self.telegram.notify_trade_exit(notification_data)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error sending exit notification: {e}")
|
|
|
|
|
|
def create_position_monitor_job(database, telegram=None):
|
|
"""
|
|
Factory-Funktion die einen Position Monitor Job erstellt
|
|
|
|
Usage:
|
|
monitor = PositionMonitor(infra.db, infra.telegram)
|
|
|
|
# Im Scheduler hinzufügen:
|
|
scheduler.add_job(
|
|
func=monitor.check_open_positions,
|
|
trigger='interval',
|
|
minutes=1, # Prüfe jede Minute
|
|
id='position_monitor'
|
|
)
|
|
"""
|
|
monitor = PositionMonitor(database, telegram)
|
|
return monitor
|
|
|
|
|
|
# ==========================================
|
|
# USAGE EXAMPLE (für Notebook)
|
|
# ==========================================
|
|
|
|
"""
|
|
Im Trading Bot Notebook hinzufügen:
|
|
|
|
# Nach Infrastructure Setup (Cell 8):
|
|
|
|
from position_monitor import PositionMonitor
|
|
|
|
# Position Monitor erstellen
|
|
position_monitor = PositionMonitor(infra.db, infra.telegram)
|
|
|
|
# Im Scheduler hinzufügen (Cell 33):
|
|
scheduler.add_job(
|
|
func=position_monitor.check_open_positions,
|
|
trigger='interval',
|
|
minutes=1,
|
|
id='position_monitor'
|
|
)
|
|
|
|
print("✅ Position Monitor aktiviert - prüft jede Minute nach geschlossenen Trades")
|
|
"""
|