diff --git a/TradingBot/CHANGELOG.md b/TradingBot/CHANGELOG.md index 8547848..273a237 100644 --- a/TradingBot/CHANGELOG.md +++ b/TradingBot/CHANGELOG.md @@ -6,6 +6,148 @@ Formato basato su [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), segu --- +## [1.5.2] - 2024-12-22 + +### Added +- **Detailed Capital Metrics in Sidebar**: Portfolio Summary espansa con metriche complete + - Capitale Totale: Somma di disponibile + investito + - Capitale Investito: Valore posizioni aperte correnti + - Capitale Disponibile: Cash disponibile per trading + - P&L Corrente: Profitto/perdita non realizzato sulle posizioni aperte + - ROI: Return on Investment percentuale sul capitale iniziale +- **Real-time Updates**: Metriche aggiornate automaticamente + - Su ogni cambio di prezzo + - Su ogni trade eseguito + - Su ogni cambio di status + +### Changed +- Portfolio Summary sidebar completamente ridisegnata +- Color-coding per metriche (verde=profit, rosso=loss, arancio=investito, blu=disponibile) +- Calcolo ROI basato su capitale iniziale + P&L realizzato e non realizzato + +### Technical +- Event-driven updates su OnPriceUpdated, OnTradeExecuted, OnStatusChanged +- Separazione chiara tra capitale investito e disponibile +- P&L calculation: (Current Value - Entry Value) per posizioni aperte + +--- + +## [1.5.1] - 2024-12-22 + +### Added +- **Positions Management Page**: Pagina dedicata gestione posizioni aperte + - Visualizzazione completa posizioni attive + - Real-time P&L unrealized calculation + - Manual close position functionality + - Confirmation modal con dettagli completi + - Header statistics (Active positions, Total value, Total P&L) + - Empty state quando nessuna posizione aperta + - Success notifications +- **ClosePositionManuallyAsync**: Metodo pubblico TradingBotService + - Close manual positions via API + - Safety checks (bot running, position exists) + - Automatic logging + +### Changed +- MainLayout navigation menu aggiornato con link Positions +- Version display aggiornata a v1.5.1 + +### Technical +- Event-driven updates per real-time P&L +- Position cards con holding time formattato +- Color-coded P&L (green=profit, red=loss) +- Modal confirmation per sicurezza +- No manual opening - solo chiusura + +--- + +## [1.5.0] - 2024-12-22 + +### Added +- **Multi-Strategy Trading System**: Sistema completo di gestione strategie multiple per asset + - 8 strategie di trading famose implementate + - Assignment multiplo strategie per asset + - Sistema di voting per decisioni aggregate + - Trading Control page dedicata +- **Trading Strategies**: 8 strategie professionali preimpostate + - RSI Strategy (Oscillator - Medium risk) + - MACD Strategy (Momentum - Medium risk) + - Bollinger Bands (Volatility - Low risk) + - Mean Reversion (Contrarian - High risk) + - Momentum (Trend Following - Medium risk) + - EMA Crossover / Golden Cross (Trend - Low risk) + - Scalping (Short-term - Very High risk) + - Breakout (Volatility - High risk) +- **TradingStrategiesService**: Gestione centralizzata strategie + - Strategy registry con metadata + - Asset-strategy mapping + - Decision aggregation con voting + - Persistence delle configurazioni +- **Trading Control Page**: Interfaccia gestione strategie + - Grid asset con stato real-time + - Strategy selector modal per category + - Visualizzazione decisioni aggregate + - Risk e timeframe indicators +- **Version Display**: Versione applicazione visibile in sidebar footer + - Version number (v1.5.0) + - Build date + +### Changed +- TradingBotService integrato con TradingStrategiesService +- MainLayout aggiornato con link Trading Control +- Navigation menu riorganizzato + +### Technical +- 8 strategy implementations (ITradingStrategy interface) +- Voting algorithm: 60% consensus threshold +- Strategy metadata: Category, Risk Level, Timeframe +- Persistence: `strategy-mappings.json` +- Confidence-based decision making + +--- + +## [1.4.0] - 2024-12-22 + +### Added +- **Indicators System**: Sistema completo di indicatori tecnici configurabili + - 7 indicatori predefiniti: RSI, MACD, SMA (20/50), EMA 12, Bollinger Bands, Stochastic + - Configurazione parametri per ogni indicatore + - Abilitazione/disabilitazione selettiva indicatori + - Soglie personalizzabili (ipercomprato/ipervenduto) +- **Indicators Page**: Interfaccia dedicata gestione indicatori + - Configurazione real-time di tutti i parametri + - Status live per ogni asset attivo + - Visualizzazione condizioni mercato + - Raccomandazioni basate su indicatori +- **Indicator Signals**: Sistema di segnali trading + - Segnali BUY/SELL/HOLD con strength rating + - Storia ultimi 100 segnali generati + - Filtro segnali per symbol + - Notifiche real-time nuovi segnali +- **Trading Recommendations**: Raccomandazioni aggregate + - Analisi multi-indicatore per ogni asset + - Livello di confidenza basato su consenso + - Lista indicatori di supporto + - Azioni consigliate (BUY/SELL/HOLD) +- **Indicator Models**: Nuovi modelli dati + - IndicatorConfig - Configurazione indicatore + - IndicatorSignal - Segnale trading + - IndicatorStatus - Status per asset + - TradingRecommendation - Raccomandazione trading + +### Changed +- MainLayout aggiornato con link Indicators +- IndicatorsService registrato come singleton +- Configurazione indicatori persistita in `indicators-config.json` + +### Technical +- Persistenza configurazione indicatori in `/app/data` +- Event-driven updates per UI real-time +- Supporto 8 tipi di indicatori (RSI, MACD, SMA, EMA, BB, Stochastic, Volume, ATR) +- Market conditions: Overbought, Oversold, Bullish, Bearish, Neutral, Ranging, Trending + +--- + ## [1.3.0] - 2024-12-21 ### Added @@ -109,6 +251,8 @@ Formato basato su [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), segu --- +[1.5.0]: https://gitea.encke-hake.ts.net/Alby96/Encelado/compare/v1.4.0...v1.5.0 +[1.4.0]: https://gitea.encke-hake.ts.net/Alby96/Encelado/compare/v1.3.0...v1.4.0 [1.3.0]: https://gitea.encke-hake.ts.net/Alby96/Encelado/compare/v1.2.0...v1.3.0 [1.2.0]: https://gitea.encke-hake.ts.net/Alby96/Encelado/compare/v1.1.0...v1.2.0 [1.1.0]: https://gitea.encke-hake.ts.net/Alby96/Encelado/compare/v1.0.0...v1.1.0 diff --git a/TradingBot/Components/Layout/MainLayout.razor b/TradingBot/Components/Layout/MainLayout.razor index a156639..2b3076c 100644 --- a/TradingBot/Components/Layout/MainLayout.razor +++ b/TradingBot/Components/Layout/MainLayout.razor @@ -41,6 +41,22 @@ } + + + @if (!sidebarCollapsed) + { + Trading Control + } + + + + + @if (!sidebarCollapsed) + { + Posizioni + } + + @if (!sidebarCollapsed) @@ -49,6 +65,14 @@ } + + + @if (!sidebarCollapsed) + { + Indicatori + } + + @if (!sidebarCollapsed) @@ -103,16 +127,51 @@ {
-
- Portfolio - $@portfolioValue.ToString("N0") +
+ Portfolio
+
- Profitto - - $@totalProfit.ToString("N2") + Capitale Totale + $@totalCapital.ToString("N2") +
+ +
+ Investito + $@investedCapital.ToString("N2") +
+ +
+ Disponibile + $@availableCapital.ToString("N2") +
+ +
+ +
+ P&L Corrente + + @(currentPL >= 0 ? "+" : "")$@currentPL.ToString("N2")
+ +
+ ROI + + @(roiPercentage >= 0 ? "+" : "")@roiPercentage.ToString("F2")% + +
+
+
+ + +
+
+ TradingBot + v1.5.2 +
+
+ Build: @DateTime.Now.ToString("yyyy-MM-dd")
} @@ -148,6 +207,11 @@ private bool isRunning => BotService.Status.IsRunning; private decimal portfolioValue = 0; private decimal totalProfit = 0; + private decimal totalCapital = 0; + private decimal investedCapital = 0; + private decimal availableCapital = 0; + private decimal currentPL = 0; + private decimal roiPercentage = 0; protected override void OnInitialized() { @@ -155,6 +219,7 @@ sidebarCollapsed = settings.SidebarCollapsed; BotService.OnStatusChanged += HandleUpdate; + BotService.OnTradeExecuted += HandleTradeExecuted; BotService.OnPriceUpdated += HandlePriceUpdate; SettingsService.OnSettingsChanged += HandleSettingsChanged; @@ -184,34 +249,69 @@ private void UpdateStats() { - portfolioValue = BotService.AssetConfigurations.Values.Sum(c => - c.CurrentBalance + (c.CurrentHoldings * (BotService.GetLatestPrice(c.Symbol)?.Price ?? 0))); - - totalProfit = BotService.AssetConfigurations.Values.Sum(c => c.TotalProfit); + totalCapital = 0; + investedCapital = 0; + availableCapital = 0; + currentPL = 0; + totalProfit = 0; + + foreach (var config in BotService.AssetConfigurations.Values) + { + if (!config.IsEnabled) continue; + + // Capitale disponibile (cash) + availableCapital += config.CurrentBalance; + + // Capitale investito in posizioni aperte + var currentPrice = BotService.GetLatestPrice(config.Symbol)?.Price ?? 0; + var positionValue = config.CurrentHoldings * currentPrice; + investedCapital += positionValue; + + // P&L non realizzato sulle posizioni aperte + if (config.CurrentHoldings > 0 && config.AverageEntryPrice > 0) + { + var entryValue = config.CurrentHoldings * config.AverageEntryPrice; + currentPL += (positionValue - entryValue); + } + + // Totale profitti/perdite realizzati + totalProfit += config.TotalProfit; + } + + // Capitale totale = Disponibile + Investito + totalCapital = availableCapital + investedCapital; + + // Portfolio value include anche i profitti realizzati + portfolioValue = totalCapital + totalProfit; + + // ROI basato sul capitale iniziale + var initialCapital = BotService.AssetConfigurations.Values + .Where(c => c.IsEnabled) + .Sum(c => c.InitialBalance); + + if (initialCapital > 0) + { + var totalGain = currentPL + totalProfit; + roiPercentage = (totalGain / initialCapital) * 100; + } + else + { + roiPercentage = 0; + } } - private void HandleUpdate() - { - UpdateStats(); - InvokeAsync(StateHasChanged); - } - - private void HandlePriceUpdate(string symbol, MarketPrice price) - { - UpdateStats(); - InvokeAsync(StateHasChanged); - } - - private void HandleSettingsChanged() - { - var settings = SettingsService.GetSettings(); - sidebarCollapsed = settings.SidebarCollapsed; - InvokeAsync(StateHasChanged); - } + private void HandleUpdate() => InvokeAsync(() => { UpdateStats(); StateHasChanged(); }); + + private void HandleTradeExecuted(Trade trade) => InvokeAsync(() => { UpdateStats(); StateHasChanged(); }); + + private void HandlePriceUpdate(string symbol, MarketPrice price) => InvokeAsync(() => { UpdateStats(); StateHasChanged(); }); + + private void HandleSettingsChanged() => InvokeAsync(StateHasChanged); public void Dispose() { BotService.OnStatusChanged -= HandleUpdate; + BotService.OnTradeExecuted -= HandleTradeExecuted; BotService.OnPriceUpdated -= HandlePriceUpdate; SettingsService.OnSettingsChanged -= HandleSettingsChanged; } diff --git a/TradingBot/Components/Layout/MainLayout.razor.css b/TradingBot/Components/Layout/MainLayout.razor.css index 14a9632..4a7c947 100644 --- a/TradingBot/Components/Layout/MainLayout.razor.css +++ b/TradingBot/Components/Layout/MainLayout.razor.css @@ -256,12 +256,35 @@ gap: 0.875rem !important; } +::deep .summary-header { + margin-bottom: 0.5rem !important; +} + +::deep .summary-section-title { + font-size: 0.875rem !important; + color: #6366f1 !important; + font-weight: 700 !important; + text-transform: uppercase !important; + letter-spacing: 0.05em !important; +} + ::deep .summary-row { display: flex !important; justify-content: space-between !important; align-items: center !important; } +::deep .summary-row.highlight { + padding-top: 0.5rem !important; + margin-top: 0.5rem !important; +} + +::deep .summary-divider { + height: 1px !important; + background: rgba(99, 102, 241, 0.2) !important; + margin: 0.25rem 0 !important; +} + ::deep .summary-title { font-size: 0.75rem !important; color: #64748b !important; @@ -285,6 +308,14 @@ color: #ef4444 !important; } +::deep .summary-amount.invested { + color: #f59e0b !important; +} + +::deep .summary-amount.available { + color: #3b82f6 !important; +} + /* ============================================== MAIN CONTENT AREA ============================================== */ @@ -466,3 +497,46 @@ padding: 1.5rem 1rem !important; } } + +/* ============================================== + VERSION FOOTER + ============================================== */ + +::deep .sidebar-footer { + padding: 1rem 1.5rem !important; + border-top: 1px solid rgba(99, 102, 241, 0.1) !important; + margin-top: auto !important; +} + +::deep .version-info { + display: flex !important; + justify-content: space-between !important; + align-items: center !important; + margin-bottom: 0.5rem !important; +} + +::deep .version-label { + font-size: 0.75rem !important; + color: #64748b !important; + font-weight: 600 !important; + text-transform: uppercase !important; + letter-spacing: 0.05em !important; +} + +::deep .version-number { + font-size: 0.875rem !important; + font-weight: 700 !important; + color: #6366f1 !important; + font-family: 'Courier New', monospace !important; +} + +::deep .build-info { + display: flex !important; + justify-content: flex-start !important; +} + +::deep .build-date { + font-size: 0.625rem !important; + color: #475569 !important; + font-family: 'Courier New', monospace !important; +} diff --git a/TradingBot/Components/Pages/Indicators.razor b/TradingBot/Components/Pages/Indicators.razor new file mode 100644 index 0000000..125b91d --- /dev/null +++ b/TradingBot/Components/Pages/Indicators.razor @@ -0,0 +1,467 @@ +@page "/indicators" +@using TradingBot.Services +@using TradingBot.Models +@inject IndicatorsService IndicatorsService +@inject TradingBotService BotService +@implements IDisposable +@rendermode InteractiveServer + +Indicatori - TradingBot + +
+
+
+

Indicatori Tecnici

+

Configura gli indicatori per analisi avanzata del mercato

+
+
+ + +
+ @foreach (var indicator in indicators.Values.OrderBy(i => !i.IsEnabled).ThenBy(i => i.Name)) + { +
+
+
+

@indicator.Name

+ @indicator.Type +
+ +
+ +

@indicator.Description

+ + @if (indicator.IsEnabled) + { +
+ @switch (indicator.Type) + { + case IndicatorType.RSI: + case IndicatorType.Stochastic: +
+ + +
+
+ + +
+
+ + +
+ break; + + case IndicatorType.MACD: +
+ + +
+
+ + +
+
+ + +
+ break; + + case IndicatorType.SMA: + case IndicatorType.EMA: + case IndicatorType.BollingerBands: +
+ + +
+ break; + } + + +
+ + +
+

Status Asset Attivi

+ @foreach (var symbol in BotService.AssetConfigurations.Values.Where(c => c.IsEnabled).Select(c => c.Symbol)) + { + var status = IndicatorsService.GetIndicatorStatus(indicator.Id, symbol); + if (status != null) + { +
+ @symbol + @status.CurrentValue.ToString("F2") + + @status.Condition + + @status.Recommendation +
+ } + } +
+ } +
+ } +
+ + +
+
+

Segnali Recenti

+ @recentSignals.Count segnali +
+ + @if (recentSignals.Count == 0) + { +
+ +

Nessun segnale generato

+
+ } + else + { +
+ @foreach (var signal in recentSignals.Take(20)) + { +
+
+ @signal.Timestamp.ToLocalTime().ToString("HH:mm:ss") + @signal.IndicatorName + @signal.Symbol + + @signal.Type + + + @signal.Strength + +
+
@signal.Message
+ @if (signal.Value.HasValue) + { +
Valore: @signal.Value.Value.ToString("F2")
+ } +
+ } +
+ } +
+
+ + + +@code { + private Dictionary indicators = new(); + private List recentSignals = new(); + + protected override void OnInitialized() + { + LoadIndicators(); + IndicatorsService.OnIndicatorsChanged += HandleIndicatorsChanged; + IndicatorsService.OnSignalGenerated += HandleSignalGenerated; + } + + private void LoadIndicators() + { + indicators = IndicatorsService.GetIndicators().ToDictionary(k => k.Key, v => v.Value); + recentSignals = IndicatorsService.GetRecentSignals().ToList(); + } + + private void ToggleIndicator(string id, bool enabled) + { + IndicatorsService.ToggleIndicator(id, enabled); + } + + private void SaveIndicator(IndicatorConfig indicator) + { + IndicatorsService.UpdateIndicator(indicator.Id, indicator); + } + + private void HandleIndicatorsChanged() + { + LoadIndicators(); + InvokeAsync(StateHasChanged); + } + + private void HandleSignalGenerated(IndicatorSignal signal) + { + recentSignals = IndicatorsService.GetRecentSignals().ToList(); + InvokeAsync(StateHasChanged); + } + + public void Dispose() + { + IndicatorsService.OnIndicatorsChanged -= HandleIndicatorsChanged; + IndicatorsService.OnSignalGenerated -= HandleSignalGenerated; + } +} diff --git a/TradingBot/Components/Pages/Positions.razor b/TradingBot/Components/Pages/Positions.razor new file mode 100644 index 0000000..8ce45f7 --- /dev/null +++ b/TradingBot/Components/Pages/Positions.razor @@ -0,0 +1,716 @@ +@page "/positions" +@using TradingBot.Services +@using TradingBot.Models +@inject TradingBotService BotService +@inject LoggingService LoggingService +@implements IDisposable +@rendermode InteractiveServer + +Posizioni Aperte - TradingBot + +
+
+
+

Posizioni Aperte

+

Gestisci le tue posizioni attive - Solo chiusura manuale disponibile

+
+
+
+ Posizioni Attive + @activePositions.Count +
+
+ Valore Totale + $@totalValue.ToString("N2") +
+
+ P&L Non Realizzato + + @(totalUnrealizedPL >= 0 ? "+" : "")$@totalUnrealizedPL.ToString("N2") + +
+
+
+ + @if (activePositions.Count == 0) + { +
+
+ +
+

Nessuna Posizione Aperta

+

Non hai posizioni attive al momento. Le posizioni appaiono qui automaticamente quando il bot esegue un acquisto.

+
+ + + Configura Trading + + + + Dashboard + +
+
+ } + else + { +
+ @foreach (var position in activePositions.OrderBy(p => p.Symbol)) + { + var currentPrice = GetCurrentPrice(position.Symbol); + var unrealizedPL = CalculateUnrealizedPL(position, currentPrice); + var plPercentage = CalculatePLPercentage(position, currentPrice); + var currentValue = position.Amount * currentPrice; + var holdingTime = DateTime.UtcNow - position.Timestamp; + +
+
+
+

@position.Symbol

+ + Aperta @position.Timestamp.ToLocalTime().ToString("dd/MM/yyyy HH:mm") + +
+
+ + @(unrealizedPL >= 0 ? "+" : "")$@unrealizedPL.ToString("N2") + + + (@(plPercentage >= 0 ? "+" : "")@plPercentage.ToString("F2")%) + +
+
+ +
+
+ Quantità + @position.Amount.ToString("F8") @position.Symbol +
+
+ Prezzo Entrata + $@position.Price.ToString("N2") +
+
+ Prezzo Corrente + $@currentPrice.ToString("N2") +
+
+ Valore Iniziale + $@(position.Amount * position.Price).ToString("N2") +
+
+ Valore Corrente + $@currentValue.ToString("N2") +
+
+ Tempo Holding + @FormatHoldingTime(holdingTime) +
+ @if (!string.IsNullOrEmpty(position.Strategy)) + { +
+ Strategia + @position.Strategy +
+ } +
+ +
+ + @if (!BotService.Status.IsRunning) + { + + + Avvia il bot per chiudere posizioni + + } +
+
+ } +
+ } + + + @if (showCloseModal && positionToClose != null) + { + var currentPrice = GetCurrentPrice(positionToClose.Symbol); + var unrealizedPL = CalculateUnrealizedPL(positionToClose, currentPrice); + var plPercentage = CalculatePLPercentage(positionToClose, currentPrice); + +
+
+
+

Conferma Chiusura Posizione

+ +
+
+
+
+

@positionToClose.Symbol

+ @positionToClose.Amount.ToString("F8") @positionToClose.Symbol +
+ +
+
+ Prezzo Entrata + $@positionToClose.Price.ToString("N2") +
+ +
+ Prezzo Chiusura + $@currentPrice.ToString("N2") +
+
+ +
+
Profitto/Perdita Stimato
+
+ @(unrealizedPL >= 0 ? "+" : "")$@unrealizedPL.ToString("N2") +
+
+ (@(plPercentage >= 0 ? "+" : "")@plPercentage.ToString("F2")%) +
+
+ +
+ +

+ Attenzione: Questa azione chiuderà immediatamente la posizione al prezzo di mercato corrente. + L'operazione non può essere annullata. +

+
+
+
+
+ + +
+
+
+ } + + + @if (showSuccessNotification) + { +
+ + Posizione chiusa con successo! +
+ } +
+ + + +@code { + private List activePositions = new(); + private decimal totalValue = 0; + private decimal totalUnrealizedPL = 0; + private bool showCloseModal = false; + private Trade? positionToClose = null; + private bool showSuccessNotification = false; + + protected override void OnInitialized() + { + LoadPositions(); + BotService.OnTradeExecuted += HandleTradeExecuted; + BotService.OnPriceUpdated += HandlePriceUpdated; + BotService.OnStatusChanged += HandleStatusChanged; + } + + private void LoadPositions() + { + activePositions = BotService.ActivePositions.Values.ToList(); + CalculateTotals(); + } + + private void CalculateTotals() + { + totalValue = 0; + totalUnrealizedPL = 0; + + foreach (var position in activePositions) + { + var currentPrice = GetCurrentPrice(position.Symbol); + var positionValue = position.Amount * currentPrice; + var pl = CalculateUnrealizedPL(position, currentPrice); + + totalValue += positionValue; + totalUnrealizedPL += pl; + } + } + + private decimal GetCurrentPrice(string symbol) + { + var latestPrice = BotService.GetLatestPrice(symbol); + return latestPrice?.Price ?? 0; + } + + private decimal CalculateUnrealizedPL(Trade position, decimal currentPrice) + { + return (currentPrice - position.Price) * position.Amount; + } + + private decimal CalculatePLPercentage(Trade position, decimal currentPrice) + { + if (position.Price == 0) return 0; + return ((currentPrice - position.Price) / position.Price) * 100; + } + + private string FormatHoldingTime(TimeSpan time) + { + if (time.TotalDays >= 1) + return $"{(int)time.TotalDays}g {time.Hours}h"; + else if (time.TotalHours >= 1) + return $"{(int)time.TotalHours}h {time.Minutes}m"; + else + return $"{(int)time.TotalMinutes}m {time.Seconds}s"; + } + + private void ShowCloseConfirmation(Trade position) + { + positionToClose = position; + showCloseModal = true; + } + + private void HideCloseConfirmation() + { + showCloseModal = false; + positionToClose = null; + } + + private async Task ConfirmClosePosition() + { + if (positionToClose == null) return; + + try + { + // Close position using TradingBotService public method + await BotService.ClosePositionManuallyAsync(positionToClose.Symbol); + + LoggingService.LogInfo( + "Positions", + $"Posizione chiusa manualmente: {positionToClose.Symbol}", + $"Quantità: {positionToClose.Amount:F8}"); + + showSuccessNotification = true; + HideCloseConfirmation(); + LoadPositions(); + + // Hide notification after 3 seconds + await Task.Delay(3000); + showSuccessNotification = false; + StateHasChanged(); + } + catch (Exception ex) + { + LoggingService.LogError("Positions", $"Errore chiusura posizione: {ex.Message}"); + } + } + + private void HandleTradeExecuted(Trade trade) + { + LoadPositions(); + InvokeAsync(StateHasChanged); + } + + private void HandlePriceUpdated(string symbol, MarketPrice price) + { + if (activePositions.Any(p => p.Symbol == symbol)) + { + CalculateTotals(); + InvokeAsync(StateHasChanged); + } + } + + private void HandleStatusChanged() + { + InvokeAsync(StateHasChanged); + } + + public void Dispose() + { + BotService.OnTradeExecuted -= HandleTradeExecuted; + BotService.OnPriceUpdated -= HandlePriceUpdated; + BotService.OnStatusChanged -= HandleStatusChanged; + } +} diff --git a/TradingBot/Components/Pages/TradingControl.razor b/TradingBot/Components/Pages/TradingControl.razor new file mode 100644 index 0000000..81a0dc0 --- /dev/null +++ b/TradingBot/Components/Pages/TradingControl.razor @@ -0,0 +1,555 @@ +@page "/trading-control" +@using TradingBot.Services +@using TradingBot.Models +@inject TradingStrategiesService StrategiesService +@inject TradingBotService BotService +@implements IDisposable +@rendermode InteractiveServer + +Trading Control - TradingBot + +
+
+
+

Trading Control

+

Gestisci le strategie di trading per ogni asset

+
+
+
+ Asset Attivi + @activeAssets +
+
+ Strategie in Uso + @totalStrategies +
+
+
+ + +
+ @foreach (var asset in BotService.AssetConfigurations.Values.OrderBy(a => a.Symbol)) + { + var mapping = StrategiesService.GetAssetMapping(asset.Symbol); + var engineStatus = StrategiesService.GetEngineStatus(asset.Symbol); + var isActive = mapping?.IsActive ?? false; + +
+
+
+

@asset.Symbol

+ @asset.Name +
+
+ +
+
+ + @if (mapping != null && mapping.StrategyIds.Count > 0) + { +
+

Strategie Assegnate (@mapping.StrategyIds.Count)

+
+ @foreach (var strategyId in mapping.StrategyIds) + { + var strategyInfo = availableStrategies[strategyId]; +
+ @strategyInfo.Name + @strategyInfo.Category + +
+ } +
+
+ + @if (engineStatus?.LastDecision != null && isActive) + { +
+

Ultima Decisione

+
+ + @engineStatus.LastDecision.Decision + + + Confidenza: @engineStatus.LastDecision.Confidence.ToString("F0")% + +
+
@engineStatus.LastDecision.Reason
+
+ Buy: @engineStatus.LastDecision.BuyVotes + Sell: @engineStatus.LastDecision.SellVotes + Hold: @engineStatus.LastDecision.HoldVotes +
+
+ } + } + +
+ +
+
+ } +
+ + + @if (showStrategySelector) + { +
+
+
+

Gestisci Strategie - @selectedAssetSymbol

+ +
+
+
+ @foreach (var category in availableStrategies.Values.Select(s => s.Category).Distinct().OrderBy(c => c)) + { +
+

@category

+
+ @foreach (var strategy in availableStrategies.Values.Where(s => s.Category == category)) + { + var isSelected = selectedStrategies.Contains(strategy.Id); +
+
+
+ +
+
+
@strategy.Name
+

@strategy.Description

+
+
+
+ + @strategy.RiskLevel Risk + + + @strategy.RecommendedTimeFrame + +
+
+ } +
+
+ } +
+
+
+ + +
+
+
+ } +
+ + + +@code { + private Dictionary availableStrategies = new(); + private bool showStrategySelector = false; + private string selectedAssetSymbol = ""; + private string selectedAssetName = ""; + private List selectedStrategies = new(); + private int activeAssets = 0; + private int totalStrategies = 0; + + protected override void OnInitialized() + { + LoadData(); + StrategiesService.OnMappingsChanged += HandleMappingsChanged; + } + + private void LoadData() + { + availableStrategies = StrategiesService.GetAvailableStrategies().ToDictionary(k => k.Key, v => v.Value); + + var mappings = StrategiesService.GetAllMappings(); + activeAssets = mappings.Values.Count(m => m.IsActive); + totalStrategies = mappings.Values.Sum(m => m.StrategyIds.Count); + } + + private void ToggleAsset(string symbol, bool active) + { + if (active) + { + StrategiesService.ActivateAsset(symbol); + } + else + { + StrategiesService.DeactivateAsset(symbol); + } + LoadData(); + } + + private void OpenStrategySelector(string symbol, string name) + { + selectedAssetSymbol = symbol; + selectedAssetName = name; + + var mapping = StrategiesService.GetAssetMapping(symbol); + selectedStrategies = mapping?.StrategyIds.ToList() ?? new List(); + + showStrategySelector = true; + } + + private void CloseStrategySelector() + { + showStrategySelector = false; + selectedStrategies.Clear(); + } + + private void ToggleStrategy(string strategyId) + { + if (selectedStrategies.Contains(strategyId)) + { + selectedStrategies.Remove(strategyId); + } + else + { + selectedStrategies.Add(strategyId); + } + } + + private void SaveStrategies() + { + StrategiesService.AssignStrategiesToAsset(selectedAssetSymbol, selectedAssetName, selectedStrategies); + CloseStrategySelector(); + LoadData(); + } + + private void RemoveStrategy(string symbol, string strategyId) + { + StrategiesService.RemoveStrategyFromAsset(symbol, strategyId); + LoadData(); + } + + private void HandleMappingsChanged() + { + LoadData(); + InvokeAsync(StateHasChanged); + } + + public void Dispose() + { + StrategiesService.OnMappingsChanged -= HandleMappingsChanged; + } +} diff --git a/TradingBot/Components/Shared/IndicatorsWidget.razor b/TradingBot/Components/Shared/IndicatorsWidget.razor new file mode 100644 index 0000000..9db156e --- /dev/null +++ b/TradingBot/Components/Shared/IndicatorsWidget.razor @@ -0,0 +1,220 @@ +@using TradingBot.Services +@using TradingBot.Models +@inject IndicatorsService IndicatorsService +@inject TradingBotService BotService +@implements IDisposable + +
+
+

Indicatori Attivi

+ + Configura + +
+ +
+ @foreach (var indicator in enabledIndicators.Take(6)) + { +
+
+ @indicator.Name + @indicator.Type +
+ + @if (topAssets.Any()) + { + var symbol = topAssets.First(); + var status = IndicatorsService.GetIndicatorStatus(indicator.Id, symbol); + + if (status != null) + { +
+ @status.CurrentValue.ToString("F2") + + @status.Condition + +
+
+ @status.Recommendation +
+ } + else + { +
Calcolo...
+ } + } + else + { +
Nessun asset attivo
+ } +
+ } +
+ + @if (enabledIndicators.Count() > 6) + { +
+ + Vedi tutti (@enabledIndicators.Count()) + +
+ } +
+ + + +@code { + private List enabledIndicators = new(); + private List topAssets = new(); + + protected override void OnInitialized() + { + LoadData(); + IndicatorsService.OnIndicatorsChanged += HandleUpdate; + BotService.OnStatusChanged += HandleUpdate; + } + + private void LoadData() + { + enabledIndicators = IndicatorsService.GetEnabledIndicators().ToList(); + topAssets = BotService.AssetConfigurations.Values + .Where(c => c.IsEnabled) + .OrderByDescending(c => c.CurrentBalance + (c.CurrentHoldings * (BotService.GetLatestPrice(c.Symbol)?.Price ?? 0))) + .Select(c => c.Symbol) + .Take(1) + .ToList(); + } + + private void HandleUpdate() + { + LoadData(); + InvokeAsync(StateHasChanged); + } + + public void Dispose() + { + IndicatorsService.OnIndicatorsChanged -= HandleUpdate; + BotService.OnStatusChanged -= HandleUpdate; + } +} diff --git a/TradingBot/Models/IndicatorModels.cs b/TradingBot/Models/IndicatorModels.cs new file mode 100644 index 0000000..6d10a7d --- /dev/null +++ b/TradingBot/Models/IndicatorModels.cs @@ -0,0 +1,94 @@ +namespace TradingBot.Models; + +/// +/// Configuration for a trading indicator +/// +public class IndicatorConfig +{ + public string Id { get; set; } = string.Empty; + public string Name { get; set; } = string.Empty; + public string Description { get; set; } = string.Empty; + public IndicatorType Type { get; set; } + public bool IsEnabled { get; set; } = true; + + // Thresholds for signals + public decimal? OverboughtThreshold { get; set; } + public decimal? OversoldThreshold { get; set; } + public decimal? BuyThreshold { get; set; } + public decimal? SellThreshold { get; set; } + + // Indicator-specific parameters + public int Period { get; set; } = 14; + public int FastPeriod { get; set; } = 12; + public int SlowPeriod { get; set; } = 26; + public int SignalPeriod { get; set; } = 9; +} + +/// +/// Real-time indicator signal +/// +public class IndicatorSignal +{ + public string IndicatorId { get; set; } = string.Empty; + public string IndicatorName { get; set; } = string.Empty; + public string Symbol { get; set; } = string.Empty; + public DateTime Timestamp { get; set; } = DateTime.UtcNow; + public SignalStrength Strength { get; set; } + public SignalType Type { get; set; } + public string Message { get; set; } = string.Empty; + public decimal? Value { get; set; } +} + +/// +/// Indicator status for a specific asset +/// +public class IndicatorStatus +{ + public string IndicatorId { get; set; } = string.Empty; + public string Symbol { get; set; } = string.Empty; + public decimal CurrentValue { get; set; } + public decimal? PreviousValue { get; set; } + public MarketCondition Condition { get; set; } + public string Recommendation { get; set; } = string.Empty; + public DateTime LastUpdate { get; set; } = DateTime.UtcNow; +} + +/// +/// Types of trading indicators +/// +public enum IndicatorType +{ + RSI, // Relative Strength Index + MACD, // Moving Average Convergence Divergence + SMA, // Simple Moving Average + EMA, // Exponential Moving Average + BollingerBands, // Bollinger Bands + Stochastic, // Stochastic Oscillator + Volume, // Volume indicators + ATR // Average True Range (volatility) +} + +/// +/// Signal strength levels +/// +public enum SignalStrength +{ + Weak, + Moderate, + Strong, + VeryStrong +} + +/// +/// Market condition based on indicators +/// +public enum MarketCondition +{ + Neutral, + Overbought, + Oversold, + Bullish, + Bearish, + Ranging, + Trending +} diff --git a/TradingBot/Models/TradingEngine.cs b/TradingBot/Models/TradingEngine.cs new file mode 100644 index 0000000..3e29383 --- /dev/null +++ b/TradingBot/Models/TradingEngine.cs @@ -0,0 +1,137 @@ +namespace TradingBot.Models; + +/// +/// Represents the mapping between an asset and its assigned trading strategies +/// +public class AssetStrategyMapping +{ + public string Symbol { get; set; } = string.Empty; + public string AssetName { get; set; } = string.Empty; + public List StrategyIds { get; set; } = new(); + public bool IsActive { get; set; } + public DateTime ActivatedAt { get; set; } + public DateTime? DeactivatedAt { get; set; } + + /// + /// Strategy-specific parameters override + /// Key: StrategyId, Value: Dictionary of parameter names and values + /// + public Dictionary> StrategyParameters { get; set; } = new(); +} + +/// +/// Represents a trading strategy instance +/// +public class StrategyInfo +{ + public string Id { get; set; } = string.Empty; + public string Name { get; set; } = string.Empty; + public string Description { get; set; } = string.Empty; + public string Category { get; set; } = string.Empty; // Trend, Oscillator, Volatility, etc. + public StrategyRisk RiskLevel { get; set; } + public TimeFrame RecommendedTimeFrame { get; set; } + public List RequiredIndicators { get; set; } = new(); + public Dictionary Parameters { get; set; } = new(); +} + +/// +/// Parameter information for strategy configuration +/// +public class ParameterInfo +{ + public string Name { get; set; } = string.Empty; + public string Description { get; set; } = string.Empty; + public ParameterType Type { get; set; } + public object DefaultValue { get; set; } = 0; + public object? MinValue { get; set; } + public object? MaxValue { get; set; } +} + +/// +/// Trading engine status for an asset +/// +public class TradingEngineStatus +{ + public string Symbol { get; set; } = string.Empty; + public bool IsRunning { get; set; } + public int ActiveStrategies { get; set; } + public DateTime? LastSignalTime { get; set; } + public List RecentSignals { get; set; } = new(); + public TradingDecision? LastDecision { get; set; } +} + +/// +/// Signal from a specific strategy +/// +public class StrategySignal +{ + public string StrategyId { get; set; } = string.Empty; + public string StrategyName { get; set; } = string.Empty; + public TradingSignal Signal { get; set; } = new(); + public DateTime GeneratedAt { get; set; } = DateTime.UtcNow; +} + +/// +/// Aggregated trading decision from multiple strategies +/// +public class TradingDecision +{ + public string Symbol { get; set; } = string.Empty; + public SignalType Decision { get; set; } + public decimal Confidence { get; set; } + public string Reason { get; set; } = string.Empty; + public int BuyVotes { get; set; } + public int SellVotes { get; set; } + public int HoldVotes { get; set; } + public List SupportingStrategies { get; set; } = new(); + public List OpposingStrategies { get; set; } = new(); + public DateTime Timestamp { get; set; } = DateTime.UtcNow; +} + +/// +/// Strategy performance metrics +/// +public class StrategyPerformance +{ + public string StrategyId { get; set; } = string.Empty; + public string Symbol { get; set; } = string.Empty; + public int TotalSignals { get; set; } + public int CorrectSignals { get; set; } + public decimal Accuracy { get; set; } + public decimal TotalProfit { get; set; } + public decimal AverageConfidence { get; set; } + public DateTime FirstSignalTime { get; set; } + public DateTime LastSignalTime { get; set; } +} + +/// +/// Risk level for strategies +/// +public enum StrategyRisk +{ + Low, + Medium, + High, + VeryHigh +} + +/// +/// Recommended time frame for strategy +/// +public enum TimeFrame +{ + ShortTerm, // Minutes to hours + MediumTerm, // Hours to days + LongTerm // Days to weeks +} + +/// +/// Parameter data type +/// +public enum ParameterType +{ + Integer, + Decimal, + Boolean, + String +} diff --git a/TradingBot/Models/TradingSignal.cs b/TradingBot/Models/TradingSignal.cs index 23305f2..a82fe66 100644 --- a/TradingBot/Models/TradingSignal.cs +++ b/TradingBot/Models/TradingSignal.cs @@ -5,6 +5,7 @@ public class TradingSignal public string Symbol { get; set; } = string.Empty; public SignalType Type { get; set; } public decimal Price { get; set; } + public decimal Confidence { get; set; } // 0-100 confidence level public string Reason { get; set; } = string.Empty; public DateTime Timestamp { get; set; } } diff --git a/TradingBot/Program.cs b/TradingBot/Program.cs index fe880e6..1b6b985 100644 --- a/TradingBot/Program.cs +++ b/TradingBot/Program.cs @@ -22,6 +22,8 @@ builder.Services.AddSingleton(); builder.Services.AddSingleton(); builder.Services.AddSingleton(); builder.Services.AddSingleton(); +builder.Services.AddSingleton(); +builder.Services.AddSingleton(); builder.Services.AddSingleton(); builder.Services.AddSingleton(); diff --git a/TradingBot/README.md b/TradingBot/README.md index 6aefaff..81b49aa 100644 --- a/TradingBot/README.md +++ b/TradingBot/README.md @@ -5,16 +5,20 @@ [![.NET 10](https://img.shields.io/badge/.NET-10.0-512BD4)](https://dotnet.microsoft.com/) [![Blazor](https://img.shields.io/badge/Blazor-Server-512BD4)](https://blazor.net/) [![Docker](https://img.shields.io/badge/Docker-Ready-2496ED)](https://www.docker.com/) -[![Version](https://img.shields.io/badge/version-1.3.0-blue)](https://gitea.encke-hake.ts.net/Alby96/Encelado/-/packages) +[![Version](https://img.shields.io/badge/version-1.5.2-blue)](https://gitea.encke-hake.ts.net/Alby96/Encelado/-/packages) --- ## ? Caratteristiche -- **Trading Algoritmico**: Simple Moving Average (SMA) strategy +- **Multi-Strategy Trading**: 8 strategie professionali assegnabili a ogni asset +- **Positions Management**: Visualizza e chiudi manualmente posizioni aperte +- **Detailed Portfolio Metrics**: Capitale totale, investito, disponibile, P&L, ROI +- **Trading Control**: Gestione visuale strategie con voting system - **Dashboard Blazor**: Real-time updates ogni 3 secondi - **15 Criptovalute**: BTC, ETH, BNB, ADA, SOL, XRP, DOT, DOGE, AVAX, MATIC, LINK, LTC, UNI, ATOM, XLM -- **Analisi Tecnica**: SMA, EMA, RSI, MACD, Bollinger Bands +- **Analisi Tecnica**: SMA, EMA, RSI, MACD, Bollinger Bands, Stochastic +- **Indicators System**: 7+ indicatori tecnici configurabili con segnali real-time - **Portfolio Management**: Gestione automatizzata posizioni - **Trade Persistence**: Salvataggio automatico trade e posizioni attive - **Comprehensive Logs**: Sistema di logging real-time con filtri avanzati @@ -22,6 +26,28 @@ --- +## ?? Trading Strategies + +### **8 Strategie Professionali** + +1. **RSI Strategy** - Oscillator (Medium Risk) +2. **MACD Strategy** - Momentum (Medium Risk) +3. **Bollinger Bands** - Volatility (Low Risk) +4. **Mean Reversion** - Contrarian (High Risk) +5. **Momentum** - Trend Following (Medium Risk) +6. **EMA Crossover** - Golden/Death Cross (Low Risk) +7. **Scalping** - Short-term (Very High Risk) +8. **Breakout** - Volatility Breakout (High Risk) + +### **Multi-Strategy System** + +- Assegna multiple strategie per asset +- Sistema di voting per decisioni aggregate +- Confidence-based trading +- Parametri configurabili per strategia + +--- + ## ?? Quick Start ### Locale (Development) @@ -64,18 +90,18 @@ wget -O /boot/config/plugins/dockerMan/templates-user/TradingBot.xml \ ## ?? Versioning -### Current Version: `1.3.0` +### Current Version: `1.5.2` -**Latest**: Comprehensive logs page con monitoring real-time +**Latest**: Metriche dettagliate capitale in sidebar (Totale, Investito, Disponibile, P&L, ROI) ```powershell -# Bug fix (1.3.0 ? 1.3.1) -.\bump-version.ps1 patch -Message "Fix memory leak" +# Bug fix (1.5.2 ? 1.5.3) +.\bump-version.ps1 patch -Message "Fix calculation bug" -# New feature (1.3.0 ? 1.4.0) -.\bump-version.ps1 minor -Message "Add RSI strategy" +# New feature (1.5.2 ? 1.6.0) +.\bump-version.ps1 minor -Message "Add new strategy" -# Breaking change (1.3.0 ? 2.0.0) +# Breaking change (1.5.2 ? 2.0.0) .\bump-version.ps1 major -Message "New API" ``` @@ -93,7 +119,7 @@ Vedi [CHANGELOG.md](CHANGELOG.md) per release notes complete. Il sistema automaticamente: - ? Build Docker image -- ? Tag: `latest`, `1.3.0`, `1.3.0-20241221` +- ? Tag: `latest`, `1.5.1`, `1.5.1-20241222` - ? Push su Gitea Registry ### Deploy su Unraid diff --git a/TradingBot/Services/IndicatorsService.cs b/TradingBot/Services/IndicatorsService.cs new file mode 100644 index 0000000..b87787f --- /dev/null +++ b/TradingBot/Services/IndicatorsService.cs @@ -0,0 +1,346 @@ +using TradingBot.Models; +using System.Text.Json; + +namespace TradingBot.Services; + +/// +/// Service for managing trading indicators configuration and signals +/// +public class IndicatorsService +{ + private readonly Dictionary _indicators = new(); + private readonly Dictionary> _indicatorStatus = new(); + private readonly List _recentSignals = new(); + private readonly string _configPath; + private const int MaxSignals = 100; + + public event Action? OnIndicatorsChanged; + public event Action? OnSignalGenerated; + + public IndicatorsService() + { + _configPath = Path.Combine(Directory.GetCurrentDirectory(), "data", "indicators-config.json"); + InitializeDefaultIndicators(); + LoadConfiguration(); + } + + private void InitializeDefaultIndicators() + { + _indicators["rsi"] = new IndicatorConfig + { + Id = "rsi", + Name = "RSI", + Description = "Relative Strength Index - Misura la forza del trend", + Type = IndicatorType.RSI, + IsEnabled = true, + Period = 14, + OverboughtThreshold = 70, + OversoldThreshold = 30 + }; + + _indicators["macd"] = new IndicatorConfig + { + Id = "macd", + Name = "MACD", + Description = "Moving Average Convergence Divergence - Identifica cambi di trend", + Type = IndicatorType.MACD, + IsEnabled = true, + FastPeriod = 12, + SlowPeriod = 26, + SignalPeriod = 9 + }; + + _indicators["sma_20"] = new IndicatorConfig + { + Id = "sma_20", + Name = "SMA 20", + Description = "Simple Moving Average 20 periodi - Trend a breve termine", + Type = IndicatorType.SMA, + IsEnabled = true, + Period = 20 + }; + + _indicators["sma_50"] = new IndicatorConfig + { + Id = "sma_50", + Name = "SMA 50", + Description = "Simple Moving Average 50 periodi - Trend a medio termine", + Type = IndicatorType.SMA, + IsEnabled = true, + Period = 50 + }; + + _indicators["ema_12"] = new IndicatorConfig + { + Id = "ema_12", + Name = "EMA 12", + Description = "Exponential Moving Average 12 periodi - Reattivo ai cambiamenti", + Type = IndicatorType.EMA, + IsEnabled = true, + Period = 12 + }; + + _indicators["bollinger"] = new IndicatorConfig + { + Id = "bollinger", + Name = "Bollinger Bands", + Description = "Bande di Bollinger - Misura volatilità e livelli estremi", + Type = IndicatorType.BollingerBands, + IsEnabled = true, + Period = 20 + }; + + _indicators["stochastic"] = new IndicatorConfig + { + Id = "stochastic", + Name = "Stochastic", + Description = "Oscillatore Stocastico - Identifica momenti di inversione", + Type = IndicatorType.Stochastic, + IsEnabled = false, + Period = 14, + OverboughtThreshold = 80, + OversoldThreshold = 20 + }; + } + + /// + /// Get all indicator configurations + /// + public IReadOnlyDictionary GetIndicators() + { + return _indicators; + } + + /// + /// Get enabled indicators only + /// + public IEnumerable GetEnabledIndicators() + { + return _indicators.Values.Where(i => i.IsEnabled); + } + + /// + /// Update indicator configuration + /// + public void UpdateIndicator(string id, IndicatorConfig config) + { + _indicators[id] = config; + SaveConfiguration(); + OnIndicatorsChanged?.Invoke(); + } + + /// + /// Toggle indicator on/off + /// + public void ToggleIndicator(string id, bool enabled) + { + if (_indicators.TryGetValue(id, out var indicator)) + { + indicator.IsEnabled = enabled; + SaveConfiguration(); + OnIndicatorsChanged?.Invoke(); + } + } + + /// + /// Update indicator status for a symbol + /// + public void UpdateIndicatorStatus(string indicatorId, string symbol, IndicatorStatus status) + { + if (!_indicatorStatus.ContainsKey(symbol)) + { + _indicatorStatus[symbol] = new Dictionary(); + } + + _indicatorStatus[symbol][indicatorId] = status; + } + + /// + /// Get indicator status for a symbol + /// + public IndicatorStatus? GetIndicatorStatus(string indicatorId, string symbol) + { + if (_indicatorStatus.TryGetValue(symbol, out var symbolIndicators)) + { + symbolIndicators.TryGetValue(indicatorId, out var status); + return status; + } + return null; + } + + /// + /// Get all indicator statuses for a symbol + /// + public IEnumerable GetSymbolIndicators(string symbol) + { + if (_indicatorStatus.TryGetValue(symbol, out var symbolIndicators)) + { + return symbolIndicators.Values; + } + return Enumerable.Empty(); + } + + /// + /// Generate and record a signal + /// + public void GenerateSignal(IndicatorSignal signal) + { + _recentSignals.Insert(0, signal); + + // Maintain max size + while (_recentSignals.Count > MaxSignals) + { + _recentSignals.RemoveAt(_recentSignals.Count - 1); + } + + OnSignalGenerated?.Invoke(signal); + } + + /// + /// Get recent signals + /// + public IReadOnlyList GetRecentSignals(int count = 20) + { + return _recentSignals.Take(count).ToList().AsReadOnly(); + } + + /// + /// Get signals for a specific symbol + /// + public IReadOnlyList GetSymbolSignals(string symbol, int count = 20) + { + return _recentSignals + .Where(s => s.Symbol.Equals(symbol, StringComparison.OrdinalIgnoreCase)) + .Take(count) + .ToList() + .AsReadOnly(); + } + + /// + /// Analyze indicators and generate trading recommendation + /// + public TradingRecommendation AnalyzeIndicators(string symbol) + { + var recommendation = new TradingRecommendation + { + Symbol = symbol, + Timestamp = DateTime.UtcNow + }; + + var symbolIndicators = GetSymbolIndicators(symbol).ToList(); + if (!symbolIndicators.Any()) + { + recommendation.Action = "HOLD"; + recommendation.Confidence = 0; + recommendation.Reason = "Indicatori non disponibili"; + return recommendation; + } + + int buySignals = 0; + int sellSignals = 0; + int totalEnabled = GetEnabledIndicators().Count(); + + foreach (var status in symbolIndicators) + { + if (!_indicators.TryGetValue(status.IndicatorId, out var config) || !config.IsEnabled) + continue; + + switch (status.Condition) + { + case MarketCondition.Oversold: + case MarketCondition.Bullish: + buySignals++; + recommendation.SupportingIndicators.Add($"{config.Name}: {status.Recommendation}"); + break; + + case MarketCondition.Overbought: + case MarketCondition.Bearish: + sellSignals++; + recommendation.SupportingIndicators.Add($"{config.Name}: {status.Recommendation}"); + break; + } + } + + // Determine action based on signals + if (buySignals > sellSignals && buySignals >= totalEnabled * 0.6m) + { + recommendation.Action = "BUY"; + recommendation.Confidence = (decimal)buySignals / totalEnabled * 100; + recommendation.Reason = $"{buySignals}/{totalEnabled} indicatori suggeriscono acquisto"; + } + else if (sellSignals > buySignals && sellSignals >= totalEnabled * 0.6m) + { + recommendation.Action = "SELL"; + recommendation.Confidence = (decimal)sellSignals / totalEnabled * 100; + recommendation.Reason = $"{sellSignals}/{totalEnabled} indicatori suggeriscono vendita"; + } + else + { + recommendation.Action = "HOLD"; + recommendation.Confidence = 50; + recommendation.Reason = "Segnali contrastanti - attendere conferma"; + } + + return recommendation; + } + + private void SaveConfiguration() + { + try + { + var directory = Path.GetDirectoryName(_configPath); + if (directory != null && !Directory.Exists(directory)) + { + Directory.CreateDirectory(directory); + } + + var json = JsonSerializer.Serialize(_indicators, new JsonSerializerOptions + { + WriteIndented = true + }); + + File.WriteAllText(_configPath, json); + } + catch (Exception ex) + { + Console.WriteLine($"Error saving indicators configuration: {ex.Message}"); + } + } + + private void LoadConfiguration() + { + try + { + if (File.Exists(_configPath)) + { + var json = File.ReadAllText(_configPath); + var loaded = JsonSerializer.Deserialize>(json); + + if (loaded != null) + { + foreach (var kvp in loaded) + { + _indicators[kvp.Key] = kvp.Value; + } + } + } + } + catch (Exception ex) + { + Console.WriteLine($"Error loading indicators configuration: {ex.Message}"); + } + } +} + +/// +/// Trading recommendation based on multiple indicators +/// +public class TradingRecommendation +{ + public string Symbol { get; set; } = string.Empty; + public DateTime Timestamp { get; set; } + public string Action { get; set; } = "HOLD"; // BUY, SELL, HOLD + public decimal Confidence { get; set; } + public string Reason { get; set; } = string.Empty; + public List SupportingIndicators { get; set; } = new(); +} diff --git a/TradingBot/Services/TechnicalAnalysis.cs b/TradingBot/Services/TechnicalAnalysis.cs index d86ccf4..2d2e207 100644 --- a/TradingBot/Services/TechnicalAnalysis.cs +++ b/TradingBot/Services/TechnicalAnalysis.cs @@ -70,4 +70,22 @@ public static class TechnicalAnalysis return (macdLine, signalLine, histogram); } + + public static (decimal upper, decimal middle, decimal lower) CalculateBollingerBands(List prices, int period = 20, decimal standardDeviations = 2) + { + if (prices.Count < period) return (0, 0, 0); + + var recentPrices = prices.TakeLast(period).ToList(); + var sma = recentPrices.Average(); + + // Calculate standard deviation + var squaredDifferences = recentPrices.Select(p => (double)Math.Pow((double)(p - sma), 2)); + var variance = squaredDifferences.Average(); + var stdDev = (decimal)Math.Sqrt(variance); + + var upper = sma + (standardDeviations * stdDev); + var lower = sma - (standardDeviations * stdDev); + + return (upper, sma, lower); + } } diff --git a/TradingBot/Services/TradingBotService.cs b/TradingBot/Services/TradingBotService.cs index 46818c1..d75c6b0 100644 --- a/TradingBot/Services/TradingBotService.cs +++ b/TradingBot/Services/TradingBotService.cs @@ -8,6 +8,8 @@ public class TradingBotService private readonly ITradingStrategy _strategy; private readonly TradeHistoryService _historyService; private readonly LoggingService _loggingService; + private readonly IndicatorsService _indicatorsService; + private readonly TradingStrategiesService _strategiesService; private readonly Dictionary _assetConfigs = new(); private readonly Dictionary _assetStats = new(); private readonly List _trades = new(); @@ -34,12 +36,16 @@ public class TradingBotService IMarketDataService marketDataService, ITradingStrategy strategy, TradeHistoryService historyService, - LoggingService loggingService) + LoggingService loggingService, + IndicatorsService indicatorsService, + TradingStrategiesService strategiesService) { _marketDataService = marketDataService; _strategy = strategy; _historyService = historyService; _loggingService = loggingService; + _indicatorsService = indicatorsService; + _strategiesService = strategiesService; Status.CurrentStrategy = strategy.Name; // Subscribe to simulated market updates if available @@ -484,8 +490,138 @@ public class TradingBotService _indicators[symbol] = indicators; OnIndicatorsUpdated?.Invoke(symbol, indicators); + + // Update IndicatorsService statuses + UpdateIndicatorStatuses(symbol, indicators, prices); } - + + private void UpdateIndicatorStatuses(string symbol, TechnicalIndicators indicators, List prices) + { + // Update RSI status + var rsiConfig = _indicatorsService.GetIndicators().Values.FirstOrDefault(i => i.Id == "rsi"); + if (rsiConfig?.IsEnabled == true) + { + var rsiStatus = new IndicatorStatus + { + IndicatorId = "rsi", + Symbol = symbol, + CurrentValue = indicators.RSI, + Condition = indicators.RSI > (rsiConfig.OverboughtThreshold ?? 70) ? MarketCondition.Overbought : + indicators.RSI < (rsiConfig.OversoldThreshold ?? 30) ? MarketCondition.Oversold : + MarketCondition.Neutral, + Recommendation = indicators.RSI > (rsiConfig.OverboughtThreshold ?? 70) ? "Possibile vendita" : + indicators.RSI < (rsiConfig.OversoldThreshold ?? 30) ? "Possibile acquisto" : + "Attendi conferma" + }; + _indicatorsService.UpdateIndicatorStatus("rsi", symbol, rsiStatus); + + // Generate signal if crossing threshold + if (indicators.RSI < 30) + { + _indicatorsService.GenerateSignal(new IndicatorSignal + { + IndicatorId = "rsi", + IndicatorName = "RSI", + Symbol = symbol, + Type = SignalType.Buy, + Strength = indicators.RSI < 20 ? SignalStrength.VeryStrong : SignalStrength.Strong, + Message = $"RSI in zona ipervenduto: {indicators.RSI:F2}", + Value = indicators.RSI + }); + } + else if (indicators.RSI > 70) + { + _indicatorsService.GenerateSignal(new IndicatorSignal + { + IndicatorId = "rsi", + IndicatorName = "RSI", + Symbol = symbol, + Type = SignalType.Sell, + Strength = indicators.RSI > 80 ? SignalStrength.VeryStrong : SignalStrength.Strong, + Message = $"RSI in zona ipercomprato: {indicators.RSI:F2}", + Value = indicators.RSI + }); + } + } + + // Update MACD status + var macdConfig = _indicatorsService.GetIndicators().Values.FirstOrDefault(i => i.Id == "macd"); + if (macdConfig?.IsEnabled == true) + { + var macdStatus = new IndicatorStatus + { + IndicatorId = "macd", + Symbol = symbol, + CurrentValue = indicators.MACD, + Condition = indicators.Histogram > 0 ? MarketCondition.Bullish : MarketCondition.Bearish, + Recommendation = indicators.Histogram > 0 ? "Trend rialzista" : "Trend ribassista" + }; + _indicatorsService.UpdateIndicatorStatus("macd", symbol, macdStatus); + + // Generate signal on crossover + if (Math.Abs(indicators.Histogram) < 0.5m) // Near crossover + { + _indicatorsService.GenerateSignal(new IndicatorSignal + { + IndicatorId = "macd", + IndicatorName = "MACD", + Symbol = symbol, + Type = indicators.Histogram > 0 ? SignalType.Buy : SignalType.Sell, + Strength = SignalStrength.Moderate, + Message = $"MACD {(indicators.Histogram > 0 ? "bullish" : "bearish")} crossover", + Value = indicators.MACD + }); + } + } + + // Update SMA statuses + var currentPrice = prices.Last(); + var sma20Config = _indicatorsService.GetIndicators().Values.FirstOrDefault(i => i.Id == "sma_20"); + if (sma20Config?.IsEnabled == true && prices.Count >= 20) + { + var sma20 = prices.TakeLast(20).Average(); + var sma20Status = new IndicatorStatus + { + IndicatorId = "sma_20", + Symbol = symbol, + CurrentValue = sma20, + Condition = currentPrice > sma20 ? MarketCondition.Bullish : MarketCondition.Bearish, + Recommendation = currentPrice > sma20 ? "Prezzo sopra media" : "Prezzo sotto media" + }; + _indicatorsService.UpdateIndicatorStatus("sma_20", symbol, sma20Status); + } + + var sma50Config = _indicatorsService.GetIndicators().Values.FirstOrDefault(i => i.Id == "sma_50"); + if (sma50Config?.IsEnabled == true && prices.Count >= 50) + { + var sma50 = prices.TakeLast(50).Average(); + var sma50Status = new IndicatorStatus + { + IndicatorId = "sma_50", + Symbol = symbol, + CurrentValue = sma50, + Condition = currentPrice > sma50 ? MarketCondition.Bullish : MarketCondition.Bearish, + Recommendation = currentPrice > sma50 ? "Trend rialzista medio termine" : "Trend ribassista medio termine" + }; + _indicatorsService.UpdateIndicatorStatus("sma_50", symbol, sma50Status); + } + + // Update EMA status + var ema12Config = _indicatorsService.GetIndicators().Values.FirstOrDefault(i => i.Id == "ema_12"); + if (ema12Config?.IsEnabled == true) + { + var ema12Status = new IndicatorStatus + { + IndicatorId = "ema_12", + Symbol = symbol, + CurrentValue = indicators.EMA12, + Condition = currentPrice > indicators.EMA12 ? MarketCondition.Bullish : MarketCondition.Bearish, + Recommendation = currentPrice > indicators.EMA12 ? "Trend positivo" : "Trend negativo" + }; + _indicatorsService.UpdateIndicatorStatus("ema_12", symbol, ema12Status); + } + } + private void UpdateAssetStatistics(string symbol, Trade trade, decimal? realizedProfit = null) { if (!_assetStats.TryGetValue(symbol, out var stats)) @@ -631,4 +767,30 @@ public class TradingBotService OnStatusChanged?.Invoke(); await Task.CompletedTask; } + + /// + /// Manually close a position + /// + public async Task ClosePositionManuallyAsync(string symbol) + { + if (!_activePositions.TryGetValue(symbol, out var position)) + { + throw new InvalidOperationException($"No active position found for {symbol}"); + } + + if (!_assetConfigs.TryGetValue(symbol, out var config)) + { + throw new InvalidOperationException($"Asset configuration not found for {symbol}"); + } + + // Get current market price + var latestPrice = GetLatestPrice(symbol); + if (latestPrice == null || latestPrice.Price <= 0) + { + throw new InvalidOperationException($"Cannot get current price for {symbol}"); + } + + // Execute sell + await ExecuteSellAsync(symbol, latestPrice.Price, config.CurrentHoldings, config); + } } diff --git a/TradingBot/Services/TradingStrategies.cs b/TradingBot/Services/TradingStrategies.cs new file mode 100644 index 0000000..8639891 --- /dev/null +++ b/TradingBot/Services/TradingStrategies.cs @@ -0,0 +1,564 @@ +using TradingBot.Models; + +namespace TradingBot.Services; + +/// +/// RSI-based trading strategy +/// Buy when RSI < oversold threshold, Sell when RSI > overbought threshold +/// +public class RSIStrategy : ITradingStrategy +{ + public string Name => "RSI Strategy"; + public string Description => "Strategia basata su Relative Strength Index. Compra in zona ipervenduto, vende in zona ipercomprato."; + + private readonly decimal _oversoldThreshold; + private readonly decimal _overboughtThreshold; + private readonly int _period; + + public RSIStrategy(decimal oversoldThreshold = 30, decimal overboughtThreshold = 70, int period = 14) + { + _oversoldThreshold = oversoldThreshold; + _overboughtThreshold = overboughtThreshold; + _period = period; + } + + public Task AnalyzeAsync(string symbol, List priceHistory) + { + if (priceHistory == null || priceHistory.Count < _period + 1) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 0, + Reason = "Dati insufficienti per RSI" + }); + } + + var prices = priceHistory.Select(p => p.Price).ToList(); + var rsi = TechnicalAnalysis.CalculateRSI(prices, _period); + + if (rsi < _oversoldThreshold) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Buy, + Confidence = (decimal)(((_oversoldThreshold - rsi) / _oversoldThreshold) * 100), + Reason = $"RSI in zona ipervenduto: {rsi:F2}" + }); + } + else if (rsi > _overboughtThreshold) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Sell, + Confidence = (decimal)(((rsi - _overboughtThreshold) / (100 - _overboughtThreshold)) * 100), + Reason = $"RSI in zona ipercomprato: {rsi:F2}" + }); + } + + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 50, + Reason = $"RSI neutro: {rsi:F2}" + }); + } +} + +/// +/// MACD-based trading strategy +/// Buy on bullish crossover, Sell on bearish crossover +/// +public class MACDStrategy : ITradingStrategy +{ + public string Name => "MACD Strategy"; + public string Description => "Strategia basata su MACD crossover. Compra su incrocio rialzista, vende su incrocio ribassista."; + + public Task AnalyzeAsync(string symbol, List priceHistory) + { + if (priceHistory == null || priceHistory.Count < 26) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 0, + Reason = "Dati insufficienti per MACD" + }); + } + + var prices = priceHistory.Select(p => p.Price).ToList(); + var (macd, signal, histogram) = TechnicalAnalysis.CalculateMACD(prices); + + if (histogram > 0 && Math.Abs(histogram) > 0.1m) + { + var confidence = Math.Min((decimal)(Math.Abs((double)histogram) * 10), 100); + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Buy, + Confidence = confidence, + Reason = $"MACD crossover rialzista, histogram: {histogram:F2}" + }); + } + else if (histogram < 0 && Math.Abs(histogram) > 0.1m) + { + var confidence = Math.Min((decimal)(Math.Abs((double)histogram) * 10), 100); + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Sell, + Confidence = confidence, + Reason = $"MACD crossover ribassista, histogram: {histogram:F2}" + }); + } + + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 30, + Reason = "MACD vicino a equilibrio" + }); + } +} + +/// +/// Bollinger Bands strategy +/// Buy when price touches lower band, Sell when price touches upper band +/// +public class BollingerBandsStrategy : ITradingStrategy +{ + public string Name => "Bollinger Bands"; + public string Description => "Compra quando il prezzo tocca la banda inferiore, vende alla banda superiore."; + + private readonly int _period; + private readonly decimal _standardDeviations; + + public BollingerBandsStrategy(int period = 20, decimal standardDeviations = 2) + { + _period = period; + _standardDeviations = standardDeviations; + } + + public Task AnalyzeAsync(string symbol, List priceHistory) + { + if (priceHistory == null || priceHistory.Count < _period) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 0, + Reason = "Dati insufficienti per Bollinger Bands" + }); + } + + var prices = priceHistory.Select(p => p.Price).ToList(); + var (upper, middle, lower) = TechnicalAnalysis.CalculateBollingerBands(prices, _period, _standardDeviations); + var currentPrice = prices.Last(); + + var distanceToLower = ((currentPrice - lower) / lower) * 100; + var distanceToUpper = ((upper - currentPrice) / upper) * 100; + + if (distanceToLower < 2) // Within 2% of lower band + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Buy, + Confidence = 80, + Reason = $"Prezzo vicino banda inferiore: ${currentPrice:F2} vs ${lower:F2}" + }); + } + else if (distanceToUpper < 2) // Within 2% of upper band + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Sell, + Confidence = 80, + Reason = $"Prezzo vicino banda superiore: ${currentPrice:F2} vs ${upper:F2}" + }); + } + + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 40, + Reason = "Prezzo tra le bande" + }); + } +} + +/// +/// Mean Reversion strategy +/// Assumes price will return to average +/// +public class MeanReversionStrategy : ITradingStrategy +{ + public string Name => "Mean Reversion"; + public string Description => "Sfrutta il ritorno del prezzo verso la media. Compra sotto media, vende sopra media."; + + private readonly int _period; + private readonly decimal _deviationThreshold; + + public MeanReversionStrategy(int period = 20, decimal deviationThreshold = 5) + { + _period = period; + _deviationThreshold = deviationThreshold; + } + + public Task AnalyzeAsync(string symbol, List priceHistory) + { + if (priceHistory == null || priceHistory.Count < _period) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 0, + Reason = "Dati insufficienti" + }); + } + + var prices = priceHistory.Select(p => p.Price).TakeLast(_period).ToList(); + var mean = prices.Average(); + var currentPrice = prices.Last(); + var deviation = ((currentPrice - mean) / mean) * 100; + + if (deviation < -_deviationThreshold) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Buy, + Confidence = Math.Min((decimal)Math.Abs((double)deviation) * 10, 100), + Reason = $"Prezzo {deviation:F2}% sotto media, probabile rimbalzo" + }); + } + else if (deviation > _deviationThreshold) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Sell, + Confidence = Math.Min((decimal)Math.Abs((double)deviation) * 10, 100), + Reason = $"Prezzo {deviation:F2}% sopra media, probabile correzione" + }); + } + + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 50, + Reason = "Prezzo vicino alla media" + }); + } +} + +/// +/// Momentum strategy +/// Follows strong trends +/// +public class MomentumStrategy : ITradingStrategy +{ + public string Name => "Momentum"; + public string Description => "Segue i trend forti. Compra su momentum positivo, vende su momentum negativo."; + + private readonly int _period; + + public MomentumStrategy(int period = 10) + { + _period = period; + } + + public Task AnalyzeAsync(string symbol, List priceHistory) + { + if (priceHistory == null || priceHistory.Count < _period + 5) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 0, + Reason = "Dati insufficienti" + }); + } + + var prices = priceHistory.Select(p => p.Price).ToList(); + var currentPrice = prices.Last(); + var pastPrice = prices[^_period]; + var momentum = ((currentPrice - pastPrice) / pastPrice) * 100; + + // Calculate rate of change + var recentPrices = prices.TakeLast(5).ToList(); + var priceChanges = new List(); + for (int i = 1; i < recentPrices.Count; i++) + { + priceChanges.Add(((recentPrices[i] - recentPrices[i - 1]) / recentPrices[i - 1]) * 100); + } + var avgChange = priceChanges.Average(); + + if (momentum > 3 && avgChange > 0) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Buy, + Confidence = Math.Min((decimal)Math.Abs((double)momentum) * 15, 100), + Reason = $"Forte momentum positivo: {momentum:F2}%" + }); + } + else if (momentum < -3 && avgChange < 0) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Sell, + Confidence = Math.Min((decimal)Math.Abs((double)momentum) * 15, 100), + Reason = $"Forte momentum negativo: {momentum:F2}%" + }); + } + + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 30, + Reason = "Momentum debole o neutro" + }); + } +} + +/// +/// EMA Crossover strategy (Golden Cross / Death Cross) +/// Buy when fast EMA crosses above slow EMA, Sell on opposite +/// +public class EMACrossoverStrategy : ITradingStrategy +{ + public string Name => "EMA Crossover"; + public string Description => "Golden Cross/Death Cross. Compra quando EMA veloce supera EMA lenta."; + + private readonly int _fastPeriod; + private readonly int _slowPeriod; + + public EMACrossoverStrategy(int fastPeriod = 12, int slowPeriod = 26) + { + _fastPeriod = fastPeriod; + _slowPeriod = slowPeriod; + } + + public Task AnalyzeAsync(string symbol, List priceHistory) + { + if (priceHistory == null || priceHistory.Count < _slowPeriod + 5) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 0, + Reason = "Dati insufficienti" + }); + } + + var prices = priceHistory.Select(p => p.Price).ToList(); + var fastEMA = TechnicalAnalysis.CalculateEMA(prices, _fastPeriod); + var slowEMA = TechnicalAnalysis.CalculateEMA(prices, _slowPeriod); + + // Calculate previous EMAs to detect crossover + var prevPrices = prices.Take(prices.Count - 1).ToList(); + var prevFastEMA = TechnicalAnalysis.CalculateEMA(prevPrices, _fastPeriod); + var prevSlowEMA = TechnicalAnalysis.CalculateEMA(prevPrices, _slowPeriod); + + var currentDiff = fastEMA - slowEMA; + var prevDiff = prevFastEMA - prevSlowEMA; + + // Golden Cross (bullish) + if (currentDiff > 0 && prevDiff <= 0) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Buy, + Confidence = 85, + Reason = $"Golden Cross! EMA{_fastPeriod} crossed above EMA{_slowPeriod}" + }); + } + // Death Cross (bearish) + else if (currentDiff < 0 && prevDiff >= 0) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Sell, + Confidence = 85, + Reason = $"Death Cross! EMA{_fastPeriod} crossed below EMA{_slowPeriod}" + }); + } + // Trend continuation + else if (currentDiff > 0) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 60, + Reason = "EMA fast sopra slow - trend rialzista confermato" + }); + } + else + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 40, + Reason = "EMA fast sotto slow - trend ribassista confermato" + }); + } + } +} + +/// +/// Scalping strategy for short-term gains +/// +public class ScalpingStrategy : ITradingStrategy +{ + public string Name => "Scalping"; + public string Description => "Strategia per guadagni rapidi a breve termine. Alta frequenza, piccoli profitti."; + + public Task AnalyzeAsync(string symbol, List priceHistory) + { + if (priceHistory == null || priceHistory.Count < 10) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 0, + Reason = "Dati insufficienti" + }); + } + + var recentPrices = priceHistory.Select(p => p.Price).TakeLast(10).ToList(); + var currentPrice = recentPrices.Last(); + var shortMA = recentPrices.TakeLast(3).Average(); + var mediumMA = recentPrices.TakeLast(7).Average(); + + // Calculate short-term volatility + var priceChanges = new List(); + for (int i = 1; i < recentPrices.Count; i++) + { + priceChanges.Add(Math.Abs(recentPrices[i] - recentPrices[i - 1])); + } + var avgVolatility = priceChanges.Average(); + var recentChange = Math.Abs(currentPrice - recentPrices[^2]); + + // Quick reversal detection + if (currentPrice < shortMA && shortMA < mediumMA && recentChange > avgVolatility * 1.5m) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Buy, + Confidence = 70, + Reason = "Possibile rimbalzo rapido" + }); + } + else if (currentPrice > shortMA && shortMA > mediumMA && recentChange > avgVolatility * 1.5m) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Sell, + Confidence = 70, + Reason = "Possibile correzione rapida" + }); + } + + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 30, + Reason = "Attesa opportunità scalping" + }); + } +} + +/// +/// Breakout strategy +/// Trades on price breaking resistance/support levels +/// +public class BreakoutStrategy : ITradingStrategy +{ + public string Name => "Breakout"; + public string Description => "Compra su rottura resistenza, vende su rottura supporto. Cattura breakout significativi."; + + private readonly int _lookbackPeriod; + + public BreakoutStrategy(int lookbackPeriod = 20) + { + _lookbackPeriod = lookbackPeriod; + } + + public Task AnalyzeAsync(string symbol, List priceHistory) + { + if (priceHistory == null || priceHistory.Count < _lookbackPeriod) + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 0, + Reason = "Dati insufficienti" + }); + } + + var prices = priceHistory.Select(p => p.Price).ToList(); + var recentPrices = prices.TakeLast(_lookbackPeriod).ToList(); + var currentPrice = prices.Last(); + + var resistance = recentPrices.Max(); + var support = recentPrices.Min(); + var range = resistance - support; + + // Breakout above resistance + if (currentPrice > resistance * 1.01m) // 1% above previous high + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Buy, + Confidence = 80, + Reason = $"Breakout sopra resistenza: ${resistance:F2}" + }); + } + // Breakdown below support + else if (currentPrice < support * 0.99m) // 1% below previous low + { + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Sell, + Confidence = 80, + Reason = $"Breakdown sotto supporto: ${support:F2}" + }); + } + + return Task.FromResult(new TradingSignal + { + Symbol = symbol, + Type = SignalType.Hold, + Confidence = 40, + Reason = $"Prezzo in range ${support:F2} - ${resistance:F2}" + }); + } +} diff --git a/TradingBot/Services/TradingStrategiesService.cs b/TradingBot/Services/TradingStrategiesService.cs new file mode 100644 index 0000000..a159495 --- /dev/null +++ b/TradingBot/Services/TradingStrategiesService.cs @@ -0,0 +1,486 @@ +using TradingBot.Models; +using System.Text.Json; + +namespace TradingBot.Services; + +/// +/// Service for managing trading strategies and their assignments to assets +/// +public class TradingStrategiesService +{ + private readonly Dictionary _availableStrategies = new(); + private readonly Dictionary _strategyInstances = new(); + private readonly Dictionary _assetMappings = new(); + private readonly Dictionary _engineStatuses = new(); + private readonly string _configPath; + + public event Action? OnMappingsChanged; + public event Action? OnDecisionMade; + + public TradingStrategiesService() + { + _configPath = Path.Combine(Directory.GetCurrentDirectory(), "data", "strategy-mappings.json"); + InitializeStrategies(); + LoadMappings(); + } + + private void InitializeStrategies() + { + // RSI Strategy + var rsiStrategy = new RSIStrategy(); + _strategyInstances["rsi"] = rsiStrategy; + _availableStrategies["rsi"] = new StrategyInfo + { + Id = "rsi", + Name = "RSI Strategy", + Description = "Relative Strength Index - Compra in ipervenduto, vende in ipercomprato", + Category = "Oscillator", + RiskLevel = StrategyRisk.Medium, + RecommendedTimeFrame = TimeFrame.ShortTerm, + RequiredIndicators = new List { "RSI" }, + Parameters = new Dictionary + { + ["oversoldThreshold"] = new() { Name = "Oversold", Description = "Soglia ipervenduto", Type = ParameterType.Decimal, DefaultValue = 30m, MinValue = 10m, MaxValue = 40m }, + ["overboughtThreshold"] = new() { Name = "Overbought", Description = "Soglia ipercomprato", Type = ParameterType.Decimal, DefaultValue = 70m, MinValue = 60m, MaxValue = 90m }, + ["period"] = new() { Name = "Period", Description = "Periodo di calcolo", Type = ParameterType.Integer, DefaultValue = 14, MinValue = 5, MaxValue = 30 } + } + }; + + // MACD Strategy + var macdStrategy = new MACDStrategy(); + _strategyInstances["macd"] = macdStrategy; + _availableStrategies["macd"] = new StrategyInfo + { + Id = "macd", + Name = "MACD Strategy", + Description = "Moving Average Convergence Divergence - Crossover rialzista/ribassista", + Category = "Momentum", + RiskLevel = StrategyRisk.Medium, + RecommendedTimeFrame = TimeFrame.MediumTerm, + RequiredIndicators = new List { "MACD", "Signal", "Histogram" } + }; + + // Bollinger Bands Strategy + var bollingerStrategy = new BollingerBandsStrategy(); + _strategyInstances["bollinger"] = bollingerStrategy; + _availableStrategies["bollinger"] = new StrategyInfo + { + Id = "bollinger", + Name = "Bollinger Bands", + Description = "Compra vicino banda inferiore, vende vicino banda superiore", + Category = "Volatility", + RiskLevel = StrategyRisk.Low, + RecommendedTimeFrame = TimeFrame.MediumTerm, + RequiredIndicators = new List { "Bollinger Bands" }, + Parameters = new Dictionary + { + ["period"] = new() { Name = "Period", Description = "Periodo SMA", Type = ParameterType.Integer, DefaultValue = 20, MinValue = 10, MaxValue = 50 }, + ["standardDeviations"] = new() { Name = "Std Dev", Description = "Deviazioni standard", Type = ParameterType.Decimal, DefaultValue = 2m, MinValue = 1m, MaxValue = 3m } + } + }; + + // Mean Reversion Strategy + var meanReversionStrategy = new MeanReversionStrategy(); + _strategyInstances["mean_reversion"] = meanReversionStrategy; + _availableStrategies["mean_reversion"] = new StrategyInfo + { + Id = "mean_reversion", + Name = "Mean Reversion", + Description = "Sfrutta il ritorno del prezzo verso la media", + Category = "Contrarian", + RiskLevel = StrategyRisk.High, + RecommendedTimeFrame = TimeFrame.ShortTerm, + RequiredIndicators = new List { "SMA" }, + Parameters = new Dictionary + { + ["period"] = new() { Name = "Period", Description = "Periodo media", Type = ParameterType.Integer, DefaultValue = 20, MinValue = 10, MaxValue = 50 }, + ["deviationThreshold"] = new() { Name = "Deviation %", Description = "Soglia deviazione", Type = ParameterType.Decimal, DefaultValue = 5m, MinValue = 2m, MaxValue = 10m } + } + }; + + // Momentum Strategy + var momentumStrategy = new MomentumStrategy(); + _strategyInstances["momentum"] = momentumStrategy; + _availableStrategies["momentum"] = new StrategyInfo + { + Id = "momentum", + Name = "Momentum", + Description = "Segue i trend forti basati su momentum", + Category = "Trend", + RiskLevel = StrategyRisk.Medium, + RecommendedTimeFrame = TimeFrame.MediumTerm, + RequiredIndicators = new List { "Price Change" }, + Parameters = new Dictionary + { + ["period"] = new() { Name = "Period", Description = "Periodo momentum", Type = ParameterType.Integer, DefaultValue = 10, MinValue = 5, MaxValue = 20 } + } + }; + + // EMA Crossover Strategy + var emaCrossoverStrategy = new EMACrossoverStrategy(); + _strategyInstances["ema_crossover"] = emaCrossoverStrategy; + _availableStrategies["ema_crossover"] = new StrategyInfo + { + Id = "ema_crossover", + Name = "EMA Crossover", + Description = "Golden Cross/Death Cross con EMA", + Category = "Trend", + RiskLevel = StrategyRisk.Low, + RecommendedTimeFrame = TimeFrame.LongTerm, + RequiredIndicators = new List { "EMA12", "EMA26" }, + Parameters = new Dictionary + { + ["fastPeriod"] = new() { Name = "Fast EMA", Description = "Periodo EMA veloce", Type = ParameterType.Integer, DefaultValue = 12, MinValue = 8, MaxValue = 20 }, + ["slowPeriod"] = new() { Name = "Slow EMA", Description = "Periodo EMA lenta", Type = ParameterType.Integer, DefaultValue = 26, MinValue = 20, MaxValue = 50 } + } + }; + + // Scalping Strategy + var scalpingStrategy = new ScalpingStrategy(); + _strategyInstances["scalping"] = scalpingStrategy; + _availableStrategies["scalping"] = new StrategyInfo + { + Id = "scalping", + Name = "Scalping", + Description = "Guadagni rapidi a breve termine", + Category = "Short-term", + RiskLevel = StrategyRisk.VeryHigh, + RecommendedTimeFrame = TimeFrame.ShortTerm, + RequiredIndicators = new List { "Short MA", "Volatility" } + }; + + // Breakout Strategy + var breakoutStrategy = new BreakoutStrategy(); + _strategyInstances["breakout"] = breakoutStrategy; + _availableStrategies["breakout"] = new StrategyInfo + { + Id = "breakout", + Name = "Breakout", + Description = "Cattura rotture di resistenza/supporto", + Category = "Volatility", + RiskLevel = StrategyRisk.High, + RecommendedTimeFrame = TimeFrame.MediumTerm, + RequiredIndicators = new List { "Resistance", "Support" }, + Parameters = new Dictionary + { + ["lookbackPeriod"] = new() { Name = "Lookback", Description = "Periodo lookback", Type = ParameterType.Integer, DefaultValue = 20, MinValue = 10, MaxValue = 50 } + } + }; + } + + /// + /// Get all available strategies + /// + public IReadOnlyDictionary GetAvailableStrategies() + { + return _availableStrategies; + } + + /// + /// Get strategies by category + /// + public IEnumerable GetStrategiesByCategory(string category) + { + return _availableStrategies.Values.Where(s => s.Category == category); + } + + /// + /// Get asset mapping + /// + public AssetStrategyMapping? GetAssetMapping(string symbol) + { + _assetMappings.TryGetValue(symbol, out var mapping); + return mapping; + } + + /// + /// Get all asset mappings + /// + public IReadOnlyDictionary GetAllMappings() + { + return _assetMappings; + } + + /// + /// Assign strategies to an asset + /// + public void AssignStrategiesToAsset(string symbol, string assetName, List strategyIds) + { + var mapping = new AssetStrategyMapping + { + Symbol = symbol, + AssetName = assetName, + StrategyIds = strategyIds, + IsActive = false, + ActivatedAt = DateTime.UtcNow + }; + + _assetMappings[symbol] = mapping; + + // Initialize engine status + if (!_engineStatuses.ContainsKey(symbol)) + { + _engineStatuses[symbol] = new TradingEngineStatus + { + Symbol = symbol, + IsRunning = false, + ActiveStrategies = 0 + }; + } + + SaveMappings(); + OnMappingsChanged?.Invoke(); + } + + /// + /// Remove strategy from asset + /// + public void RemoveStrategyFromAsset(string symbol, string strategyId) + { + if (_assetMappings.TryGetValue(symbol, out var mapping)) + { + mapping.StrategyIds.Remove(strategyId); + if (mapping.StrategyIds.Count == 0) + { + mapping.IsActive = false; + } + SaveMappings(); + OnMappingsChanged?.Invoke(); + } + } + + /// + /// Activate trading for an asset + /// + public void ActivateAsset(string symbol) + { + if (_assetMappings.TryGetValue(symbol, out var mapping) && mapping.StrategyIds.Count > 0) + { + mapping.IsActive = true; + mapping.ActivatedAt = DateTime.UtcNow; + mapping.DeactivatedAt = null; + + if (_engineStatuses.TryGetValue(symbol, out var status)) + { + status.IsRunning = true; + status.ActiveStrategies = mapping.StrategyIds.Count; + } + + SaveMappings(); + OnMappingsChanged?.Invoke(); + } + } + + /// + /// Deactivate trading for an asset + /// + public void DeactivateAsset(string symbol) + { + if (_assetMappings.TryGetValue(symbol, out var mapping)) + { + mapping.IsActive = false; + mapping.DeactivatedAt = DateTime.UtcNow; + + if (_engineStatuses.TryGetValue(symbol, out var status)) + { + status.IsRunning = false; + } + + SaveMappings(); + OnMappingsChanged?.Invoke(); + } + } + + /// + /// Analyze market with assigned strategies + /// + public async Task AnalyzeAsync(string symbol, List priceHistory) + { + if (!_assetMappings.TryGetValue(symbol, out var mapping) || !mapping.IsActive) + { + return new TradingDecision + { + Symbol = symbol, + Decision = SignalType.Hold, + Confidence = 0, + Reason = "Trading non attivo per questo asset" + }; + } + + var signals = new List(); + int buyVotes = 0, sellVotes = 0, holdVotes = 0; + decimal totalConfidence = 0; + + // Execute all assigned strategies + foreach (var strategyId in mapping.StrategyIds) + { + if (_strategyInstances.TryGetValue(strategyId, out var strategy)) + { + var signal = await strategy.AnalyzeAsync(symbol, priceHistory); + + var strategySignal = new StrategySignal + { + StrategyId = strategyId, + StrategyName = _availableStrategies[strategyId].Name, + Signal = signal, + GeneratedAt = DateTime.UtcNow + }; + + signals.Add(strategySignal); + + switch (signal.Type) + { + case SignalType.Buy: + buyVotes++; + break; + case SignalType.Sell: + sellVotes++; + break; + case SignalType.Hold: + holdVotes++; + break; + } + + totalConfidence += signal.Confidence; + } + } + + // Update engine status + if (_engineStatuses.TryGetValue(symbol, out var status)) + { + status.RecentSignals = signals; + status.LastSignalTime = DateTime.UtcNow; + } + + // Aggregate decision + var decision = MakeDecision(symbol, signals, buyVotes, sellVotes, holdVotes, totalConfidence); + + if (status != null) + { + status.LastDecision = decision; + } + + OnDecisionMade?.Invoke(symbol, decision); + return decision; + } + + private TradingDecision MakeDecision(string symbol, List signals, int buyVotes, int sellVotes, int holdVotes, decimal totalConfidence) + { + var totalVotes = buyVotes + sellVotes + holdVotes; + if (totalVotes == 0) + { + return new TradingDecision + { + Symbol = symbol, + Decision = SignalType.Hold, + Confidence = 0, + Reason = "Nessuna strategia attiva" + }; + } + + var avgConfidence = totalConfidence / totalVotes; + SignalType finalDecision; + string reason; + List supporting = new(); + List opposing = new(); + + // Decision logic: majority voting with confidence threshold + if (buyVotes > sellVotes && buyVotes >= totalVotes * 0.6m) + { + finalDecision = SignalType.Buy; + reason = $"{buyVotes}/{totalVotes} strategie suggeriscono acquisto"; + supporting = signals.Where(s => s.Signal.Type == SignalType.Buy).Select(s => s.StrategyName).ToList(); + opposing = signals.Where(s => s.Signal.Type != SignalType.Buy).Select(s => s.StrategyName).ToList(); + } + else if (sellVotes > buyVotes && sellVotes >= totalVotes * 0.6m) + { + finalDecision = SignalType.Sell; + reason = $"{sellVotes}/{totalVotes} strategie suggeriscono vendita"; + supporting = signals.Where(s => s.Signal.Type == SignalType.Sell).Select(s => s.StrategyName).ToList(); + opposing = signals.Where(s => s.Signal.Type != SignalType.Sell).Select(s => s.StrategyName).ToList(); + } + else + { + finalDecision = SignalType.Hold; + reason = "Segnali contrastanti - attendi conferma"; + supporting = signals.Where(s => s.Signal.Type == SignalType.Hold).Select(s => s.StrategyName).ToList(); + } + + return new TradingDecision + { + Symbol = symbol, + Decision = finalDecision, + Confidence = avgConfidence, + Reason = reason, + BuyVotes = buyVotes, + SellVotes = sellVotes, + HoldVotes = holdVotes, + SupportingStrategies = supporting, + OpposingStrategies = opposing + }; + } + + /// + /// Get trading engine status for asset + /// + public TradingEngineStatus? GetEngineStatus(string symbol) + { + _engineStatuses.TryGetValue(symbol, out var status); + return status; + } + + private void SaveMappings() + { + try + { + var directory = Path.GetDirectoryName(_configPath); + if (directory != null && !Directory.Exists(directory)) + { + Directory.CreateDirectory(directory); + } + + var json = JsonSerializer.Serialize(_assetMappings, new JsonSerializerOptions + { + WriteIndented = true + }); + + File.WriteAllText(_configPath, json); + } + catch (Exception ex) + { + Console.WriteLine($"Error saving strategy mappings: {ex.Message}"); + } + } + + private void LoadMappings() + { + try + { + if (File.Exists(_configPath)) + { + var json = File.ReadAllText(_configPath); + var loaded = JsonSerializer.Deserialize>(json); + + if (loaded != null) + { + foreach (var kvp in loaded) + { + _assetMappings[kvp.Key] = kvp.Value; + + // Initialize engine status + _engineStatuses[kvp.Key] = new TradingEngineStatus + { + Symbol = kvp.Key, + IsRunning = kvp.Value.IsActive, + ActiveStrategies = kvp.Value.StrategyIds.Count + }; + } + } + } + } + catch (Exception ex) + { + Console.WriteLine($"Error loading strategy mappings: {ex.Message}"); + } + } +} diff --git a/TradingBot/manual-push.ps1 b/TradingBot/manual-push.ps1 new file mode 100644 index 0000000..b949bf5 --- /dev/null +++ b/TradingBot/manual-push.ps1 @@ -0,0 +1,113 @@ +#!/usr/bin/env pwsh +<# +.SYNOPSIS + Manual push of Docker image to Gitea Registry +.DESCRIPTION + Pushes the local tradingbot:latest image to Gitea Registry with proper tags + Use this when Visual Studio Publish was done without Docker running +#> + +param( + [string]$Version = "1.3.0" +) + +$ErrorActionPreference = "Stop" + +Write-Host "" +Write-Host "========================================" -ForegroundColor Cyan +Write-Host "?? Manual Gitea Registry Push" -ForegroundColor Cyan +Write-Host "========================================" -ForegroundColor Cyan +Write-Host "" + +# Check Docker +Write-Host "?? Checking Docker..." -ForegroundColor Yellow +try { + docker version | Out-Null + Write-Host "? Docker is running" -ForegroundColor Green +} catch { + Write-Host "? Docker is not running!" -ForegroundColor Red + Write-Host " Please start Docker Desktop first" -ForegroundColor Yellow + exit 1 +} +Write-Host "" + +# Check local image exists +Write-Host "?? Checking local image..." -ForegroundColor Yellow +$localImage = docker images --format "{{.Repository}}:{{.Tag}}" | Select-String "^tradingbot:latest$" +if (-not $localImage) { + Write-Host "? Local image 'tradingbot:latest' not found!" -ForegroundColor Red + Write-Host " Please run Visual Studio Publish first" -ForegroundColor Yellow + exit 1 +} +Write-Host "? Local image found: tradingbot:latest" -ForegroundColor Green +Write-Host "" + +# Configuration +$registry = "gitea.encke-hake.ts.net" +$repository = "alby96/encelado/tradingbot" +$giteaImage = "$registry/$repository" +$buildDate = Get-Date -Format "yyyyMMdd" +$versionedTag = "$Version-$buildDate" + +Write-Host "?? Version: $Version" -ForegroundColor Cyan +Write-Host "?? Build Date: $buildDate" -ForegroundColor Cyan +Write-Host "" + +# Create tags +Write-Host "??? Creating tags..." -ForegroundColor Yellow + +Write-Host " Tagging: ${giteaImage}:latest" -ForegroundColor Gray +docker tag tradingbot:latest "${giteaImage}:latest" +Write-Host " ? latest" -ForegroundColor Green + +Write-Host " Tagging: ${giteaImage}:$Version" -ForegroundColor Gray +docker tag tradingbot:latest "${giteaImage}:$Version" +Write-Host " ? $Version" -ForegroundColor Green + +Write-Host " Tagging: ${giteaImage}:$versionedTag" -ForegroundColor Gray +docker tag tradingbot:latest "${giteaImage}:$versionedTag" +Write-Host " ? $versionedTag" -ForegroundColor Green + +Write-Host "" + +# Push to Gitea +Write-Host "?? Pushing to $registry..." -ForegroundColor Yellow +Write-Host "" + +Write-Host " Pushing: latest..." -ForegroundColor Gray +docker push "${giteaImage}:latest" +Write-Host " ? Pushed: latest" -ForegroundColor Green + +Write-Host " Pushing: $Version..." -ForegroundColor Gray +docker push "${giteaImage}:$Version" +Write-Host " ? Pushed: $Version" -ForegroundColor Green + +Write-Host " Pushing: $versionedTag..." -ForegroundColor Gray +docker push "${giteaImage}:$versionedTag" +Write-Host " ? Pushed: $versionedTag" -ForegroundColor Green + +Write-Host "" +Write-Host "========================================" -ForegroundColor Green +Write-Host "? Successfully pushed to Gitea Registry!" -ForegroundColor Green +Write-Host "========================================" -ForegroundColor Green +Write-Host "" + +Write-Host "?? Published images:" -ForegroundColor Cyan +Write-Host " - ${giteaImage}:latest" -ForegroundColor White +Write-Host " - ${giteaImage}:$Version" -ForegroundColor White +Write-Host " - ${giteaImage}:$versionedTag" -ForegroundColor White +Write-Host "" + +Write-Host "?? Verify at:" -ForegroundColor Cyan +Write-Host " https://$registry/Alby96/Encelado/-/packages" -ForegroundColor White +Write-Host "" + +Write-Host "?? Next steps:" -ForegroundColor Cyan +Write-Host " 1. Verify on Gitea Packages (link above)" -ForegroundColor White +Write-Host " 2. SSH to Unraid: ssh root@192.168.30.23" -ForegroundColor White +Write-Host " 3. Force update:" -ForegroundColor White +Write-Host " docker stop TradingBot" -ForegroundColor Gray +Write-Host " docker rmi $giteaImage:latest" -ForegroundColor Gray +Write-Host " docker pull $giteaImage:latest" -ForegroundColor Gray +Write-Host " docker start TradingBot" -ForegroundColor Gray +Write-Host ""