456 lines
21 KiB
C#
456 lines
21 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Text.Json;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using FinlyticCore.Dtos;
|
|
using FinlyticCore.Dtos.Settings;
|
|
using FinlyticCore.Dtos.TechnicalAnalysis;
|
|
using FinlyticCore.Models;
|
|
using FinlyticCore.Models.Trades;
|
|
using FinlyticCore.Services;
|
|
using FinlyticCore.Util;
|
|
using FinlyticTrades.Entities;
|
|
using FinlyticTrades.Services;
|
|
using Microsoft.Extensions.Configuration;
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using Microsoft.Extensions.Hosting;
|
|
using Microsoft.Extensions.Logging;
|
|
|
|
namespace FinlyticTrades.Util;
|
|
|
|
public class TradesMqttClient : ManagedMqttClient, IHostedService
|
|
{
|
|
private readonly IConfiguration _configuration;
|
|
private readonly IServiceScopeFactory _scopeFactory;
|
|
private readonly ILogger<TradesMqttClient> _logger;
|
|
|
|
public TradesMqttClient(
|
|
IConfiguration configuration,
|
|
IServiceScopeFactory scopeFactory,
|
|
ILogger<TradesMqttClient> logger) : base(logger)
|
|
{
|
|
_configuration = configuration;
|
|
_scopeFactory = scopeFactory;
|
|
_logger = logger;
|
|
}
|
|
|
|
public async Task StartAsync(CancellationToken cancellationToken)
|
|
{
|
|
var config = new MqttConfiguration
|
|
{
|
|
Host = _configuration["MQTT:Host"] ?? _configuration["MQTT__Host"] ?? "localhost",
|
|
Port = Convert.ToInt32(_configuration["MQTT:Port"] ?? _configuration["MQTT__Port"] ?? "1883"),
|
|
Username = _configuration["MQTT:Username"] ?? _configuration["MQTT__Username"],
|
|
Password = _configuration["MQTT:Password"] ?? _configuration["MQTT__Password"],
|
|
ClientId = $"{(_configuration["MQTT:ClientId"] ?? _configuration["MQTT__ClientId"] ?? "finlytic_trades")}_{Guid.NewGuid():N}"
|
|
};
|
|
|
|
_logger.LogInformation("Starting Unified Trades MQTT Client. Host: {Host}, ClientId: {ClientId}", config.Host, config.ClientId);
|
|
await ConnectAsync(config);
|
|
}
|
|
|
|
public async Task StopAsync(CancellationToken cancellationToken)
|
|
{
|
|
_logger.LogInformation("Stopping Unified Trades MQTT Client.");
|
|
await DisconnectAsync();
|
|
}
|
|
|
|
protected override async Task OnConnectedAsync()
|
|
{
|
|
_logger.LogInformation("Trades MQTT Client connected. Subscribing to topics...");
|
|
|
|
await SubscribeAsync("finlytic/trades/proposed/#");
|
|
await SubscribeAsync("finlytic/trades/updates/#");
|
|
await SubscribeAsync("finlytic/trades/accept/#");
|
|
await SubscribeAsync("services/request/trades_Get/#");
|
|
await SubscribeAsync("services/request/trades_Close/#");
|
|
await SubscribeAsync("services/request/trades_Reject/#");
|
|
await SubscribeAsync("services/request/trades_Accept/#");
|
|
await SubscribeAsync("services/request/trades_settings_GetAll/#");
|
|
await SubscribeAsync("services/request/trades_settings_Update/#");
|
|
await SubscribeAsync("services/config/updated/#");
|
|
await SubscribeAsync("services/request/health_Ping/#");
|
|
await SubscribeAsync("services/response/tr_GetLivePrice/#");
|
|
|
|
FinlyticCore.Services.FinlyticLogBroadcaster.OnLogPublished = async (logDto) =>
|
|
{
|
|
if (IsConnected && string.Equals(logDto.ServiceName, "FinlyticTrades", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
await PublishAsync("finlytic/logs/FinlyticTrades", logDto);
|
|
}
|
|
};
|
|
|
|
_logger.LogInformation("Successfully subscribed to all event and RPC channels.");
|
|
}
|
|
|
|
protected override async Task OnMessageReceivedAsync(string topic, string payloadStr)
|
|
{
|
|
try
|
|
{
|
|
if (topic.Contains("health_Ping", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var segments = topic.Split('/');
|
|
bool isForMe = segments.Length >= 5
|
|
? segments[3].Equals("FinlyticTrades", StringComparison.OrdinalIgnoreCase)
|
|
: topic.Contains("FinlyticTrades", StringComparison.OrdinalIgnoreCase);
|
|
|
|
if (isForMe)
|
|
{
|
|
var correlationId = segments[^1];
|
|
string respTopic = $"services/response/health_Ping/{correlationId}";
|
|
var healthResp = new ServiceHealthResponse("FinlyticTrades", "Online", DateTime.UtcNow, "Connected");
|
|
await PublishAsync(respTopic, healthResp);
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var finlyticLogger = scope.ServiceProvider.GetRequiredService<IFinlyticLogger<TradesMqttClient>>();
|
|
await finlyticLogger.LogInfoAsync(SettingKeys.HealthPingChannel, "[TradesMqttClient] Responded to live health_Ping RPC request [CorrelationId: {CorrelationId}].", correlationId);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (topic.StartsWith("services/config/updated", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
if (topic.EndsWith("FinlyticTrades", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var payload = JsonSerializer.Deserialize(payloadStr, FinlyticJsonSerializerContext.Default.ServiceConfigUpdatePayload);
|
|
if (payload?.Settings != null && payload.Settings.Count > 0)
|
|
{
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var settings = scope.ServiceProvider.GetRequiredService<ISettingsService>();
|
|
var dict = payload.Settings.ToDictionary(k => k.Key, v => (object?)v.Value);
|
|
await settings.UpdateSettingsAsync(dict);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (topic.StartsWith("services/request/trades_settings_GetAll", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var correlationId = topic.Split('/').Last();
|
|
await HandleSettingsGetAllAsync(correlationId);
|
|
return;
|
|
}
|
|
|
|
if (topic.StartsWith("services/request/trades_settings_Update", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var correlationId = topic.Split('/').Last();
|
|
await HandleSettingsUpdateAsync(payloadStr, correlationId);
|
|
return;
|
|
}
|
|
|
|
using var msgScope = _scopeFactory.CreateScope();
|
|
var tradeLifecycleService = msgScope.ServiceProvider.GetRequiredService<ITradeLifecycleService>();
|
|
var finlyticLoggerInstance = msgScope.ServiceProvider.GetRequiredService<IFinlyticLogger<TradesMqttClient>>();
|
|
|
|
if (topic.StartsWith("finlytic/trades/proposed/"))
|
|
{
|
|
var proposal = JsonSerializer.Deserialize(payloadStr, FinlyticJsonSerializerContext.Default.TradeProposalDto);
|
|
if (proposal != null && (!string.IsNullOrWhiteSpace(proposal.Symbol) || !string.IsNullOrWhiteSpace(proposal.Isin)))
|
|
{
|
|
await tradeLifecycleService.ProcessProposedTradeAsync(proposal, CancellationToken.None);
|
|
}
|
|
else
|
|
{
|
|
await finlyticLoggerInstance.LogWarningAsync(SettingKeys.TradesChannel, "[TradesMqttClient] Received proposed trade payload but Symbol/ISIN is empty. Skipping ingestion.");
|
|
}
|
|
}
|
|
else if (topic.StartsWith("finlytic/trades/accept/"))
|
|
{
|
|
var acceptDto = JsonSerializer.Deserialize(payloadStr, FinlyticJsonSerializerContext.Default.TradeAcceptanceDto);
|
|
if (acceptDto != null)
|
|
{
|
|
var newTrade = await tradeLifecycleService.AcceptTradeAsync(acceptDto, CancellationToken.None);
|
|
if (newTrade != null)
|
|
{
|
|
var dto = MapToDto(newTrade);
|
|
await PublishTradeUpdateAsync(dto);
|
|
}
|
|
}
|
|
}
|
|
else if (topic.StartsWith("services/request/trades_Accept/"))
|
|
{
|
|
var correlationId = topic.Split('/').Last();
|
|
var acceptDto = JsonSerializer.Deserialize(payloadStr, FinlyticJsonSerializerContext.Default.TradeAcceptanceDto);
|
|
if (acceptDto != null)
|
|
{
|
|
var acceptedTrade = await tradeLifecycleService.AcceptTradeAsync(acceptDto, CancellationToken.None);
|
|
if (acceptedTrade != null)
|
|
{
|
|
var acceptedDto = MapToDto(acceptedTrade);
|
|
await PublishAsync($"services/response/trades_Accept/{correlationId}", acceptedDto);
|
|
await PublishTradeUpdateAsync(acceptedDto);
|
|
}
|
|
}
|
|
}
|
|
else if (topic.StartsWith("finlytic/trades/updates/"))
|
|
{
|
|
var update = JsonSerializer.Deserialize(payloadStr, FinlyticJsonSerializerContext.Default.TradeHourlyUpdateDto);
|
|
if (update != null)
|
|
{
|
|
await tradeLifecycleService.AddHourlyUpdateAsync(update, CancellationToken.None);
|
|
}
|
|
}
|
|
else if (topic.StartsWith("services/request/trades_Get/"))
|
|
{
|
|
var correlationId = topic.Split('/').Last();
|
|
var request = JsonSerializer.Deserialize(payloadStr, FinlyticJsonSerializerContext.Default.GetTradesRequest);
|
|
|
|
string? isin = request?.Isin;
|
|
string? status = request?.Status;
|
|
string? userId = request?.UserId;
|
|
|
|
var trades = await tradeLifecycleService.GetTradesAsync(isin, status, userId);
|
|
|
|
var activeTrades = trades.Where(t => t.Status == TradeStatus.Active && !string.IsNullOrWhiteSpace(t.Isin)).ToList();
|
|
if (activeTrades.Count > 0)
|
|
{
|
|
try
|
|
{
|
|
var priceTasks = activeTrades.Select(t => FetchLivePriceAsync(t.Isin)).ToList();
|
|
var livePricesTask = Task.WhenAll(priceTasks);
|
|
if (await Task.WhenAny(livePricesTask, Task.Delay(1500)) == livePricesTask)
|
|
{
|
|
var livePrices = await livePricesTask;
|
|
for (int i = 0; i < activeTrades.Count; i++)
|
|
{
|
|
var lp = livePrices[i];
|
|
if (lp != null && lp.CurrentPrice > 0m)
|
|
{
|
|
var trade = activeTrades[i];
|
|
tradeLifecycleService.CalculatePnL(trade, lp.CurrentPrice);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await finlyticLoggerInstance.LogDebugAsync(SettingKeys.TradesChannel, "[TradesMqttClient] Live price fetch skipped or timed out during trades_Get: {Message}", ex.Message);
|
|
}
|
|
}
|
|
|
|
var dtos = trades.Select(MapToDto).ToList();
|
|
await PublishAsync($"services/response/trades_Get/{correlationId}", dtos);
|
|
}
|
|
else if (topic.StartsWith("services/request/trades_Close/"))
|
|
{
|
|
var parts = topic.Split('/');
|
|
var tradeId = parts.Length > 3 ? parts[3] : string.Empty;
|
|
var correlationId = parts.Length > 4 ? parts[4] : string.Empty;
|
|
|
|
var request = JsonSerializer.Deserialize(payloadStr, FinlyticJsonSerializerContext.Default.CloseTradeRequest);
|
|
|
|
if (request != null && !string.IsNullOrEmpty(tradeId))
|
|
{
|
|
var closedTrade = await tradeLifecycleService.CloseTradeAsync(tradeId, request);
|
|
if (closedTrade != null)
|
|
{
|
|
var closedDto = MapToDto(closedTrade);
|
|
await PublishAsync($"services/response/trades_Close/{correlationId}", closedDto);
|
|
|
|
string sectorSafe = string.IsNullOrWhiteSpace(closedTrade.Sector) ? "general" : closedTrade.Sector.ToLowerInvariant();
|
|
await PublishAsync($"finlytic/trades/closed/{sectorSafe}/{closedTrade.Symbol.ToLowerInvariant()}", closedDto);
|
|
await PublishTradeUpdateAsync(closedDto);
|
|
}
|
|
}
|
|
}
|
|
else if (topic.StartsWith("services/request/trades_Reject/"))
|
|
{
|
|
var parts = topic.Split('/');
|
|
var tradeId = parts.Length > 3 ? parts[3] : string.Empty;
|
|
var correlationId = parts.Length > 4 ? parts[4] : string.Empty;
|
|
|
|
var request = JsonSerializer.Deserialize(payloadStr, FinlyticJsonSerializerContext.Default.CloseTradeRequest);
|
|
|
|
if (request != null && !string.IsNullOrEmpty(tradeId))
|
|
{
|
|
var rejectedTrade = await tradeLifecycleService.RejectTradeAsync(tradeId, request);
|
|
if (rejectedTrade != null)
|
|
{
|
|
var rejectedDto = MapToDto(rejectedTrade);
|
|
await PublishAsync($"services/response/trades_Reject/{correlationId}", rejectedDto);
|
|
await PublishTradeUpdateAsync(rejectedDto);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var finlyticLogger = scope.ServiceProvider.GetRequiredService<IFinlyticLogger<TradesMqttClient>>();
|
|
await finlyticLogger.LogErrorAsync(SettingKeys.TradesChannel, ex, "[TradesMqttClient] Error processing incoming MQTT message on topic {Topic}", topic);
|
|
}
|
|
}
|
|
|
|
private async Task HandleSettingsGetAllAsync(string correlationId)
|
|
{
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var finlyticLogger = scope.ServiceProvider.GetRequiredService<IFinlyticLogger<TradesMqttClient>>();
|
|
var settingsService = scope.ServiceProvider.GetRequiredService<ISettingsService>();
|
|
|
|
await finlyticLogger.LogInfoAsync(SettingKeys.MqttChannel, "[FinlyticTrades] [Settings_GetAll] Retrieving all dynamic settings via reflection [CorrelationId: {CorrelationId}]", correlationId);
|
|
try
|
|
{
|
|
var settings = await settingsService.GetAllRegisteredSettingsAsync(new[] { typeof(SettingKeys) });
|
|
var responseTopic = $"services/response/trades_settings_GetAll/{correlationId}";
|
|
|
|
await PublishAsync(responseTopic, settings);
|
|
await finlyticLogger.LogInfoAsync(SettingKeys.MqttChannel, "[FinlyticTrades] [Settings_GetAll] Published {Count} settings to '{ResponseTopic}'", settings.Count, responseTopic);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await finlyticLogger.LogErrorAsync(SettingKeys.MqttChannel, ex, "[FinlyticTrades] [Settings_GetAll] Failed to retrieve settings.");
|
|
}
|
|
}
|
|
|
|
private async Task HandleSettingsUpdateAsync(string payload, string correlationId)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(payload)) return;
|
|
|
|
using var scope = _scopeFactory.CreateScope();
|
|
var finlyticLogger = scope.ServiceProvider.GetRequiredService<IFinlyticLogger<TradesMqttClient>>();
|
|
var settingsService = scope.ServiceProvider.GetRequiredService<ISettingsService>();
|
|
|
|
await finlyticLogger.LogInfoAsync(SettingKeys.MqttChannel, "[FinlyticTrades] [Settings_Update] Processing settings update RPC [CorrelationId: {CorrelationId}]", correlationId);
|
|
try
|
|
{
|
|
Dictionary<string, object?>? updates = null;
|
|
try
|
|
{
|
|
updates = JsonSerializer.Deserialize<Dictionary<string, object?>>(payload);
|
|
}
|
|
catch
|
|
{
|
|
var list = JsonSerializer.Deserialize<List<DynamicSettingDto>>(payload);
|
|
if (list != null)
|
|
{
|
|
updates = new Dictionary<string, object?>();
|
|
foreach (var item in list) updates[item.Key] = item.Value;
|
|
}
|
|
}
|
|
|
|
if (updates != null && updates.Count > 0)
|
|
{
|
|
await settingsService.UpdateSettingsAsync(updates);
|
|
await finlyticLogger.LogInfoAsync(SettingKeys.MqttChannel, "[FinlyticTrades] [Settings_Update] Successfully updated {Count} settings in database and cache.", updates.Count);
|
|
}
|
|
|
|
var currentSettings = await settingsService.GetAllRegisteredSettingsAsync(new[] { typeof(SettingKeys) });
|
|
var responseTopic = $"services/response/trades_settings_Update/{correlationId}";
|
|
await PublishAsync(responseTopic, currentSettings);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
await finlyticLogger.LogErrorAsync(SettingKeys.MqttChannel, ex, "[FinlyticTrades] [Settings_Update] Failed to update settings.");
|
|
}
|
|
}
|
|
|
|
public async Task PublishTradeUpdateAsync(TradeProposalDto trade)
|
|
{
|
|
await PublishAsync($"finlytic/trades/user/{trade.UserId ?? "all"}", trade);
|
|
await PublishAsync("finlytic/trades/update", trade);
|
|
}
|
|
|
|
private async Task<LivePriceDto?> FetchLivePriceAsync(string isin)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(isin)) return null;
|
|
try
|
|
{
|
|
return await SendRpcRequestAsync<LivePriceDto, IsinRequest>(
|
|
"tr_GetLivePrice",
|
|
new IsinRequest(isin),
|
|
TimeSpan.FromMilliseconds(1200));
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
private static TradeProposalDto MapToDto(TradeEntity t)
|
|
{
|
|
List<decimal>? parseTakeProfitTargets()
|
|
{
|
|
if (string.IsNullOrWhiteSpace(t.TakeProfitTargets)) return null;
|
|
|
|
var list = new List<decimal>();
|
|
var parts = t.TakeProfitTargets.Split(',', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries);
|
|
foreach (var part in parts)
|
|
{
|
|
if (decimal.TryParse(part, NumberStyles.Number, CultureInfo.InvariantCulture, out var val))
|
|
{
|
|
list.Add(val);
|
|
}
|
|
}
|
|
return list.Count > 0 ? list : null;
|
|
}
|
|
|
|
return new TradeProposalDto
|
|
{
|
|
TradeId = t.TradeId,
|
|
Status = t.Status.ToString(),
|
|
AnalysisId = t.AnalysisId,
|
|
EventId = t.EventId,
|
|
Sector = t.Sector,
|
|
Symbol = t.Symbol,
|
|
Isin = t.Isin,
|
|
CompanyName = t.CompanyName,
|
|
EntryPrice = t.EntryPrice,
|
|
StopLoss = t.StopLoss,
|
|
TakeProfit = t.TakeProfit,
|
|
SignalType = t.SignalType,
|
|
RiskTolerance = t.RiskTolerance,
|
|
Timeframe = t.Timeframe,
|
|
InstrumentType = t.InstrumentType,
|
|
AssetType = t.AssetType,
|
|
HasCfd = t.HasCfd,
|
|
DerivativeProductCategories = t.DerivativeProductCategories ?? new List<string>(),
|
|
DerivativeIsin = t.DerivativeIsin,
|
|
WinRate = t.WinRate,
|
|
VixRegime = t.VixRegime,
|
|
VixValue = t.VixValue,
|
|
TtlMinutes = t.TtlMinutes,
|
|
Reasoning = t.Reasoning,
|
|
EntryZoneMin = t.EntryZoneMin,
|
|
EntryZoneMax = t.EntryZoneMax,
|
|
TakeProfitTargets = parseTakeProfitTargets(),
|
|
RiskRewardRatio = t.RiskRewardRatio,
|
|
MaxLeverage = t.MaxLeverage,
|
|
TechnicalRationale = t.TechnicalRationale,
|
|
FundamentalRationale = t.FundamentalRationale,
|
|
RiskWarning = t.RiskWarning,
|
|
CreatedAt = t.CreatedAt,
|
|
|
|
UserId = t.UserId,
|
|
IsGlobalProposal = t.IsGlobalProposal,
|
|
ActualEntryPrice = t.ActualEntryPrice,
|
|
PositionSize = t.PositionSize,
|
|
LeverageUsed = t.LeverageUsed,
|
|
EntryFee = t.EntryFee,
|
|
ExitFee = t.ExitFee,
|
|
ExecutionTimestamp = t.ExecutionTimestamp,
|
|
Quantity = t.Quantity,
|
|
KnockoutThreshold = t.KnockoutThreshold,
|
|
IsRecurring = t.IsRecurring,
|
|
PnlAbsolute = t.PnlAbsolute,
|
|
PnlPercent = t.PnlPercent,
|
|
CurrentPrice = t.UserExitPrice ?? t.HourlyUpdates?.LastOrDefault()?.CurrentPrice,
|
|
CloseReason = t.CloseReason,
|
|
UserExitTimestamp = t.UserExitTimestamp,
|
|
HasPendingExitAlert = t.Status == TradeStatus.Active && t.HourlyUpdates != null && t.HourlyUpdates.Any(u => string.Equals(u.Recommendation, "Close", StringComparison.OrdinalIgnoreCase)),
|
|
PendingExitReason = t.Status == TradeStatus.Active ? t.HourlyUpdates?.LastOrDefault(u => string.Equals(u.Recommendation, "Close", StringComparison.OrdinalIgnoreCase))?.Reasoning : null,
|
|
HourlyUpdates = t.HourlyUpdates?.OrderBy(u => u.Timestamp).Select(u => new TradeHourlyUpdateDto
|
|
{
|
|
TradeId = t.TradeId,
|
|
Recommendation = u.Recommendation,
|
|
CurrentPrice = u.CurrentPrice,
|
|
SuggestedStopLoss = u.SuggestedStopLoss,
|
|
SuggestedTakeProfit = u.SuggestedTakeProfit,
|
|
VixValue = u.VixValue,
|
|
Reasoning = u.Reasoning,
|
|
Timestamp = u.Timestamp
|
|
}).ToList()
|
|
};
|
|
}
|
|
} |