382 lines
16 KiB
C#
382 lines
16 KiB
C#
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using FinlyticCore.Dtos.TechnicalAnalysis;
|
|
using FinlyticCore.Services;
|
|
using FinlyticCore.Services.TradeRepublic;
|
|
using FinlyticTechnicalAnalysis.Database;
|
|
using FinlyticTechnicalAnalysis.Entities;
|
|
using FinlyticTechnicalAnalysis.Util;
|
|
using Microsoft.EntityFrameworkCore;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
|
|
namespace FinlyticTechnicalAnalysis.Services;
|
|
|
|
public interface ITechnicalAnalysisDbService
|
|
{
|
|
Task<TechnicalAnalysisDto?> GetAnalysisAsync(string isin, bool forceRefresh = false, string? ticker = null,
|
|
CancellationToken cancellationToken = default);
|
|
|
|
Task<LivePriceDto?> GetLivePriceAsync(string isin, CancellationToken cancellationToken = default);
|
|
}
|
|
|
|
public class TechnicalAnalysisDbService : ITechnicalAnalysisDbService
|
|
{
|
|
private readonly IServiceScopeFactory _scopeFactory;
|
|
private readonly IYahooMarketDataScraper _yahooScraper;
|
|
private readonly ITradeRepublicService _trService;
|
|
private readonly ITechnicalAnalysisCalculator _calculator;
|
|
private readonly IFinlyticLogger<TechnicalAnalysisDbService> _finlyticLogger;
|
|
|
|
private static readonly ConcurrentDictionary<string, (List<MarketCandleEntity> Candles, string Symbol, string Currency, DateTime FetchedAt)> _candleCache = new();
|
|
private static readonly ConcurrentDictionary<string, SemaphoreSlim> _perIsinLocks = new();
|
|
private static readonly TimeSpan CandleCacheTtl = TimeSpan.FromMinutes(15);
|
|
private static readonly TimeSpan DbCacheTtl = TimeSpan.FromHours(1);
|
|
|
|
public TechnicalAnalysisDbService(
|
|
IServiceScopeFactory scopeFactory,
|
|
IYahooMarketDataScraper yahooScraper,
|
|
ITradeRepublicService trService,
|
|
ITechnicalAnalysisCalculator calculator,
|
|
IFinlyticLogger<TechnicalAnalysisDbService> finlyticLogger)
|
|
{
|
|
_scopeFactory = scopeFactory;
|
|
_yahooScraper = yahooScraper;
|
|
_trService = trService;
|
|
_calculator = calculator;
|
|
_finlyticLogger = finlyticLogger;
|
|
}
|
|
|
|
public async Task<TechnicalAnalysisDto?> GetAnalysisAsync(string isin, bool forceRefresh = false, string? ticker = null,
|
|
CancellationToken cancellationToken = default)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(isin)) return null;
|
|
var cleanIsin = isin.Trim().ToUpperInvariant();
|
|
|
|
if (!forceRefresh && _candleCache.TryGetValue(cleanIsin, out var ramEntry) &&
|
|
DateTime.UtcNow - ramEntry.FetchedAt < CandleCacheTtl &&
|
|
(string.IsNullOrWhiteSpace(ticker) || string.Equals(ramEntry.Symbol, ticker, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
await _finlyticLogger.LogDebugAsync(SettingKeys.TechnicalAnalysisChannel, "[TechnicalAnalysisDbService] RAM-Cache Hit for ISIN {Isin}. Merging live price...", cleanIsin);
|
|
return await BuildAnalysisWithLivePriceAsync(cleanIsin, ramEntry.Candles, ramEntry.Symbol, ramEntry.Currency, cancellationToken);
|
|
}
|
|
|
|
var semaphore = _perIsinLocks.GetOrAdd(cleanIsin, _ => new SemaphoreSlim(1, 1));
|
|
await semaphore.WaitAsync(cancellationToken);
|
|
|
|
try
|
|
{
|
|
if (!forceRefresh && _candleCache.TryGetValue(cleanIsin, out ramEntry) &&
|
|
DateTime.UtcNow - ramEntry.FetchedAt < CandleCacheTtl &&
|
|
(string.IsNullOrWhiteSpace(ticker) || string.Equals(ramEntry.Symbol, ticker, StringComparison.OrdinalIgnoreCase)))
|
|
{
|
|
return await BuildAnalysisWithLivePriceAsync(cleanIsin, ramEntry.Candles, ramEntry.Symbol, ramEntry.Currency, cancellationToken);
|
|
}
|
|
|
|
if (!forceRefresh)
|
|
{
|
|
var dbDto = await GetFromDbCacheAsync(cleanIsin, ticker, cancellationToken);
|
|
if (dbDto != null)
|
|
{
|
|
await _finlyticLogger.LogDebugAsync(SettingKeys.TechnicalAnalysisChannel, "[TechnicalAnalysisDbService] DB-Cache Hit for ISIN {Isin}.", cleanIsin);
|
|
return dbDto;
|
|
}
|
|
}
|
|
|
|
return await FullRefreshAsync(cleanIsin, ticker, cancellationToken);
|
|
}
|
|
finally
|
|
{
|
|
semaphore.Release();
|
|
if (semaphore.CurrentCount == 1)
|
|
{
|
|
_perIsinLocks.TryRemove(cleanIsin, out _);
|
|
}
|
|
}
|
|
}
|
|
|
|
public async Task<LivePriceDto?> GetLivePriceAsync(string isin, CancellationToken cancellationToken = default)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(isin)) return null;
|
|
var cleanIsin = isin.Trim().ToUpperInvariant();
|
|
|
|
var (livePrice, liveBid, liveAsk, preChange) = await FetchLivePriceAsync(cleanIsin, cancellationToken);
|
|
if (!livePrice.HasValue) return null;
|
|
|
|
return new LivePriceDto(
|
|
cleanIsin,
|
|
Math.Round(livePrice.Value, 2),
|
|
preChange ?? 0m,
|
|
liveBid.HasValue ? Math.Round(liveBid.Value, 2) : null,
|
|
liveAsk.HasValue ? Math.Round(liveAsk.Value, 2) : null
|
|
);
|
|
}
|
|
|
|
private async Task<TechnicalAnalysisDto?> FullRefreshAsync(string cleanIsin, string? requestedTicker, CancellationToken cancellationToken)
|
|
{
|
|
await _finlyticLogger.LogInfoAsync(SettingKeys.TechnicalAnalysisChannel, "[TechnicalAnalysisDbService] Full refresh for ISIN {Isin} (RequestedTicker: {Ticker})", cleanIsin, requestedTicker ?? "None");
|
|
|
|
var macroTask = FetchMacroDataAsync(cancellationToken);
|
|
|
|
string? ticker = requestedTicker;
|
|
if (string.IsNullOrWhiteSpace(ticker) || string.Equals(ticker.Trim(), cleanIsin, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
ticker = await _yahooScraper.ResolveTickerFromIsinAsync(cleanIsin, cancellationToken);
|
|
}
|
|
|
|
var querySymbol = !string.IsNullOrEmpty(ticker) ? ticker : cleanIsin;
|
|
var (vix, gspc, dxy) = await macroTask;
|
|
|
|
var yahooResult = await _yahooScraper.FetchHistoricalCandlesWithCurrencyAsync(querySymbol, "2y", "1d", cancellationToken);
|
|
var candles = yahooResult.Candles;
|
|
var currency = yahooResult.Currency;
|
|
|
|
if (candles.Count == 0 && querySymbol != cleanIsin)
|
|
{
|
|
yahooResult = await _yahooScraper.FetchHistoricalCandlesWithCurrencyAsync(cleanIsin, "2y", "1d", cancellationToken);
|
|
candles = yahooResult.Candles;
|
|
currency = yahooResult.Currency;
|
|
}
|
|
|
|
if (candles.Count == 0)
|
|
{
|
|
await _finlyticLogger.LogWarningAsync(SettingKeys.TechnicalAnalysisChannel, "[TechnicalAnalysisDbService] No candles retrieved for {Symbol}", querySymbol);
|
|
return null;
|
|
}
|
|
|
|
_candleCache[cleanIsin] = (candles.Select(CloneCandle).ToList(), querySymbol, currency, DateTime.UtcNow);
|
|
|
|
await MergeLivePriceAsync(cleanIsin, candles, querySymbol, currency, cancellationToken);
|
|
|
|
var resultDto = BuildDto(cleanIsin, querySymbol, currency, candles, vix, gspc, dxy);
|
|
|
|
await PersistToDbCacheAsync(cleanIsin, querySymbol, resultDto, cancellationToken);
|
|
|
|
return resultDto;
|
|
}
|
|
|
|
private async Task<TechnicalAnalysisDto> BuildAnalysisWithLivePriceAsync(
|
|
string cleanIsin, List<MarketCandleEntity> cachedCandles, string querySymbol, string currency,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var candles = cachedCandles.Select(CloneCandle).ToList();
|
|
|
|
var livePriceTask = FetchLivePriceAsync(cleanIsin, cancellationToken);
|
|
var macroTask = FetchMacroDataAsync(cancellationToken);
|
|
|
|
await Task.WhenAll(livePriceTask, macroTask);
|
|
|
|
var (livePrice, liveBid, liveAsk, preChange) = await livePriceTask;
|
|
var (vix, gspc, dxy) = await macroTask;
|
|
|
|
ApplyLivePriceToCandles(cleanIsin, candles, querySymbol, currency, livePrice, liveBid, liveAsk);
|
|
|
|
return BuildDto(cleanIsin, querySymbol, currency, candles, vix, gspc, dxy);
|
|
}
|
|
|
|
private async Task MergeLivePriceAsync(string cleanIsin, List<MarketCandleEntity> candles, string querySymbol, string currency,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var (livePrice, liveBid, liveAsk, _) = await FetchLivePriceAsync(cleanIsin, cancellationToken);
|
|
ApplyLivePriceToCandles(cleanIsin, candles, querySymbol, currency, livePrice, liveBid, liveAsk);
|
|
}
|
|
|
|
private void ApplyLivePriceToCandles(
|
|
string cleanIsin, List<MarketCandleEntity> candles, string querySymbol, string candleCurrency,
|
|
decimal? livePrice, decimal? liveBid, decimal? liveAsk)
|
|
{
|
|
if (!livePrice.HasValue || livePrice.Value <= 0m) return;
|
|
|
|
if (candleCurrency.Equals("USD", StringComparison.OrdinalIgnoreCase) && !cleanIsin.StartsWith("DE") && !cleanIsin.StartsWith("AT"))
|
|
{
|
|
_ = _finlyticLogger.LogDebugAsync(SettingKeys.TechnicalAnalysisChannel, "[TechnicalAnalysisDbService] Skipping direct EUR live price injection for USD asset {Isin}", cleanIsin);
|
|
return;
|
|
}
|
|
|
|
var today = DateTime.UtcNow.Date;
|
|
var lastCandle = candles.LastOrDefault(c => c.Timestamp.Date == today) ?? candles.LastOrDefault();
|
|
|
|
if (lastCandle != null)
|
|
{
|
|
lastCandle.Close = livePrice.Value;
|
|
lastCandle.High = Math.Max(lastCandle.High, livePrice.Value);
|
|
lastCandle.Low = Math.Min(lastCandle.Low, livePrice.Value);
|
|
if (liveBid.HasValue) lastCandle.Bid = liveBid.Value;
|
|
if (liveAsk.HasValue) lastCandle.Ask = liveAsk.Value;
|
|
}
|
|
}
|
|
|
|
private async Task<(decimal? livePrice, decimal? liveBid, decimal? liveAsk, decimal? preChange)> FetchLivePriceAsync(
|
|
string cleanIsin, CancellationToken cancellationToken)
|
|
{
|
|
decimal? livePrice = null;
|
|
decimal? liveBid = null;
|
|
decimal? liveAsk = null;
|
|
decimal? preChange = null;
|
|
|
|
try
|
|
{
|
|
using var cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
|
|
cts.CancelAfter(1500);
|
|
|
|
var trTask = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
|
|
|
|
int? subId = await _trService.SubscribeRealtimeTickerAsync(cleanIsin, tick =>
|
|
{
|
|
decimal? effectivePrice = tick.Bid?.PriceValue > 0m
|
|
? tick.Bid.PriceValue
|
|
: (tick.Last?.PriceValue > 0m ? tick.Last.PriceValue : null);
|
|
|
|
if (effectivePrice.HasValue)
|
|
{
|
|
livePrice = tick.Last?.PriceValue ?? effectivePrice.Value;
|
|
liveBid = tick.Bid?.PriceValue;
|
|
liveAsk = tick.Ask?.PriceValue;
|
|
|
|
decimal prePrice = tick.Pre?.PriceValue ?? 0m;
|
|
|
|
if (prePrice > 0m)
|
|
{
|
|
preChange = Math.Round(((effectivePrice.Value - prePrice) / prePrice) * 100m, 2);
|
|
}
|
|
|
|
trTask.TrySetResult(true);
|
|
}
|
|
}, cts.Token);
|
|
|
|
if (subId.HasValue)
|
|
{
|
|
try
|
|
{
|
|
await trTask.Task.WaitAsync(cts.Token);
|
|
}
|
|
catch (OperationCanceledException) { }
|
|
|
|
await _trService.UnsubscribeRealtimeTickerAsync(subId.Value);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await _finlyticLogger.LogWarningAsync(SettingKeys.TechnicalAnalysisChannel, ex, "[TechnicalAnalysisDbService] Real-time price fetch skipped for ISIN {Isin}", cleanIsin);
|
|
}
|
|
|
|
return (livePrice, liveBid, liveAsk, preChange);
|
|
}
|
|
|
|
private async Task<(MacroDataEntity vix, MacroDataEntity gspc, MacroDataEntity dxy)> FetchMacroDataAsync(
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var vixTask = _yahooScraper.FetchMacroTickerAsync("^VIX", cancellationToken);
|
|
var gspcTask = _yahooScraper.FetchMacroTickerAsync("^GSPC", cancellationToken);
|
|
var dxyTask = _yahooScraper.FetchMacroTickerAsync("DX-Y.NY", cancellationToken);
|
|
|
|
await Task.WhenAll(vixTask, gspcTask, dxyTask);
|
|
|
|
var vix = await vixTask ?? new MacroDataEntity { Symbol = "^VIX", Value = 18.5m, TrendState = "Moderate" };
|
|
var gspc = await gspcTask ?? new MacroDataEntity { Symbol = "^GSPC", Value = 5500m, TrendState = "Bullish" };
|
|
var dxy = await dxyTask ?? new MacroDataEntity { Symbol = "DX-Y.NY", Value = 104.2m, TrendState = "Neutral" };
|
|
|
|
return (vix, gspc, dxy);
|
|
}
|
|
|
|
private TechnicalAnalysisDto BuildDto(string cleanIsin, string querySymbol, string currency,
|
|
List<MarketCandleEntity> candles, MacroDataEntity vix, MacroDataEntity gspc, MacroDataEntity dxy)
|
|
{
|
|
var vixRegime = vix.Value > 25m ? "HighVolatility" : (vix.Value > 18m ? "Moderate" : "LowVolatility");
|
|
var summaryText = $"Markt-Vola (VIX: {vix.Value:F1}) ist {vixRegime}. S&P 500 Trend ist {gspc.TrendState}. DXY: {dxy.Value:F1}.";
|
|
|
|
var marketRegime = new MarketRegimeDto(
|
|
VixValue: vix.Value, VixRegime: vixRegime,
|
|
MarketTrend: gspc.TrendState, DxyValue: dxy.Value,
|
|
DxyState: dxy.TrendState == "Bullish" ? "DollarStrengthening" : "DollarWeakening",
|
|
SummaryText: summaryText);
|
|
|
|
var (indicators, patterns, signals) = _calculator.CalculateAnalysis(candles, currency);
|
|
|
|
var candleDtos = candles.Select(c => new CandleDto(
|
|
Timestamp: c.Timestamp, Open: c.Open, High: c.High,
|
|
Low: c.Low, Close: c.Close, Volume: c.Volume,
|
|
Bid: c.Bid, Ask: c.Ask)).ToList();
|
|
|
|
return new TechnicalAnalysisDto(
|
|
Isin: cleanIsin, Ticker: querySymbol, CompanyName: querySymbol,
|
|
LastUpdated: DateTime.UtcNow, Candles: candleDtos,
|
|
Indicators: indicators, Patterns: patterns, Signals: signals,
|
|
MarketRegime: marketRegime, Currency: currency);
|
|
}
|
|
|
|
private async Task<TechnicalAnalysisDto?> GetFromDbCacheAsync(string cleanIsin, string? requestedTicker, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<TechnicalAnalysisDbContext>();
|
|
var cached = await db.CachedAnalyses
|
|
.AsNoTracking()
|
|
.FirstOrDefaultAsync(c => c.Isin == cleanIsin, cancellationToken);
|
|
|
|
if (cached != null && DateTime.UtcNow - cached.CalculatedAt < DbCacheTtl)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(requestedTicker) &&
|
|
!string.Equals(requestedTicker.Trim(), cleanIsin, StringComparison.OrdinalIgnoreCase) &&
|
|
!string.Equals(cached.Ticker, requestedTicker, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return null;
|
|
}
|
|
return JsonSerializer.Deserialize<TechnicalAnalysisDto>(cached.AnalysisJson);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await _finlyticLogger.LogWarningAsync(SettingKeys.TechnicalAnalysisChannel, ex, "[TechnicalAnalysisDbService] Failed to read DB cache for ISIN {Isin}", cleanIsin);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private async Task PersistToDbCacheAsync(string cleanIsin, string querySymbol, TechnicalAnalysisDto dto,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var db = scope.ServiceProvider.GetRequiredService<TechnicalAnalysisDbContext>();
|
|
var json = JsonSerializer.Serialize(dto);
|
|
|
|
var existing = await db.CachedAnalyses.FirstOrDefaultAsync(c => c.Isin == cleanIsin, cancellationToken);
|
|
if (existing != null)
|
|
{
|
|
existing.Ticker = querySymbol;
|
|
existing.AnalysisJson = json;
|
|
existing.CalculatedAt = DateTime.UtcNow;
|
|
}
|
|
else
|
|
{
|
|
db.CachedAnalyses.Add(new CachedAnalysisEntity
|
|
{
|
|
Isin = cleanIsin,
|
|
Ticker = querySymbol,
|
|
AnalysisJson = json,
|
|
CalculatedAt = DateTime.UtcNow
|
|
});
|
|
}
|
|
|
|
await db.SaveChangesAsync(cancellationToken);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await _finlyticLogger.LogErrorAsync(SettingKeys.TechnicalAnalysisChannel, ex, "[TechnicalAnalysisDbService] Failed to persist TA DB cache for ISIN {Isin}", cleanIsin);
|
|
}
|
|
}
|
|
|
|
private static MarketCandleEntity CloneCandle(MarketCandleEntity c) => new()
|
|
{
|
|
Symbol = c.Symbol, Interval = c.Interval, Timestamp = c.Timestamp,
|
|
Open = c.Open, High = c.High, Low = c.Low, Close = c.Close,
|
|
Volume = c.Volume, Bid = c.Bid, Ask = c.Ask
|
|
};
|
|
} |