542 lines
24 KiB
C#
542 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Net.Http;
|
|
using System.Net.Http.Headers;
|
|
using System.Threading.Tasks;
|
|
using Alpaca.Markets;
|
|
using DesktopBot.Models;
|
|
using Newtonsoft.Json.Linq;
|
|
|
|
namespace DesktopBot.Services
|
|
{
|
|
/// <summary>
|
|
/// Implementazione del servizio di trading per Alpaca Markets API v2.
|
|
///
|
|
/// Conformità documentazione Alpaca:
|
|
/// - Autenticazione: SecretKey (header APCA-API-KEY-ID / APCA-API-SECRET-KEY)
|
|
/// - Paper Trading: Environments.Paper → paper-api.alpaca.markets
|
|
/// - Live Trading: Environments.Live → api.alpaca.markets
|
|
/// - Market Data: data.alpaca.markets (sempre, sia paper che live)
|
|
/// - Feed dati: "iex" (piano Basic gratuito; "sip" richiede Algo Trader Plus)
|
|
/// - Rate limit: 200 req/min Market Data, ~100 req/min Trading (Basic plan)
|
|
/// </summary>
|
|
/// <summary>
|
|
/// Implementazione locale di IBar per dati crypto deserializzati dall'API REST.
|
|
/// </summary>
|
|
internal sealed class SimpleBar : IBar
|
|
{
|
|
public string Symbol { get; set; }
|
|
public DateTime TimeUtc { get; set; }
|
|
public decimal Open { get; set; }
|
|
public decimal High { get; set; }
|
|
public decimal Low { get; set; }
|
|
public decimal Close { get; set; }
|
|
public decimal Volume { get; set; }
|
|
public decimal Vwap { get; set; }
|
|
public ulong TradeCount { get; set; }
|
|
}
|
|
|
|
public class AlpacaTradingService : ITradingService
|
|
{
|
|
private IAlpacaTradingClient _tradingClient;
|
|
private IAlpacaDataClient _dataClient;
|
|
private IAlpacaCryptoDataClient _cryptoDataClient;
|
|
private string _apiKey;
|
|
private string _apiSecret;
|
|
private bool _isInitialized;
|
|
|
|
private static readonly HttpClient _httpClient = new HttpClient();
|
|
private const string CryptoDataBaseUrl = "https://data.alpaca.markets";
|
|
|
|
/// <summary>Contatore e rate-limiter per le chiamate API Alpaca.</summary>
|
|
public ApiCallCounterService ApiCounter { get; } = new ApiCallCounterService();
|
|
|
|
/// <summary>
|
|
/// Inizializza i client per il trading e i dati di mercato.
|
|
/// Autenticazione tramite API Key/Secret (header APCA-API-KEY-ID / APCA-API-SECRET-KEY).
|
|
/// </summary>
|
|
public void Initialize(string apiKey, string apiSecret, bool isPaper)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(apiKey) || string.IsNullOrWhiteSpace(apiSecret))
|
|
throw new ArgumentException("API Key e Secret sono obbligatori");
|
|
|
|
// Paper: paper-api.alpaca.markets (Trading) + data.alpaca.markets (Market Data)
|
|
// Live: api.alpaca.markets (Trading) + data.alpaca.markets (Market Data)
|
|
var environments = isPaper ? Environments.Paper : Environments.Live;
|
|
var secretKey = new SecretKey(apiKey, apiSecret);
|
|
|
|
_apiKey = apiKey;
|
|
_apiSecret = apiSecret;
|
|
|
|
_tradingClient = environments.GetAlpacaTradingClient(secretKey);
|
|
_dataClient = environments.GetAlpacaDataClient(secretKey);
|
|
_cryptoDataClient = environments.GetAlpacaCryptoDataClient(secretKey);
|
|
|
|
_isInitialized = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera l'equity disponibile del conto.
|
|
/// </summary>
|
|
public async Task<decimal> GetAvailableEquityAsync()
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "GetAvailableEquity").ConfigureAwait(false);
|
|
IAccount account = await _tradingClient.GetAccountAsync();
|
|
return account.Equity ?? 0m;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera le informazioni complete del conto.
|
|
/// </summary>
|
|
public async Task<IAccount> GetAccountAsync()
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "GetAccount").ConfigureAwait(false);
|
|
return await _tradingClient.GetAccountAsync();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera le barre storiche per un simbolo.
|
|
/// Per simboli crypto (contengono '/') usa l'endpoint REST v1beta3/crypto/us/bars
|
|
/// con paginazione automatica. Per simboli equity usa il feed IEX.
|
|
/// </summary>
|
|
public async Task<List<IBar>> GetHistoricalBarsAsync(string symbol, BarTimeFrame timeframe, int barCount)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.MarketData, "GetHistoricalBars").ConfigureAwait(false);
|
|
|
|
bool isCrypto = symbol.Contains("/") ||
|
|
symbol.Equals("BTCUSD", StringComparison.OrdinalIgnoreCase) ||
|
|
symbol.Equals("BTC/USD", StringComparison.OrdinalIgnoreCase);
|
|
|
|
if (isCrypto)
|
|
return await GetCryptoHistoricalBarsAsync(symbol, timeframe, barCount).ConfigureAwait(false);
|
|
|
|
// --- Equity: usa IAlpacaDataClient + feed IEX ---
|
|
DateTime endTime = DateTime.UtcNow;
|
|
DateTime startTime = CalculateStartTime(endTime, timeframe, (int)(barCount * 1.5));
|
|
var interval = new Interval<DateTime>(startTime, endTime);
|
|
var request = new HistoricalBarsRequest(symbol, timeframe, interval)
|
|
{
|
|
Feed = MarketDataFeed.Iex
|
|
};
|
|
IPage<IBar> page = await _dataClient.ListHistoricalBarsAsync(request).ConfigureAwait(false);
|
|
return page.Items.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera barre storiche crypto tramite chiamata diretta REST
|
|
/// GET /v1beta3/crypto/us/bars con paginazione automatica.
|
|
/// </summary>
|
|
private async Task<List<IBar>> GetCryptoHistoricalBarsAsync(
|
|
string symbol, BarTimeFrame timeframe, int barCount)
|
|
{
|
|
string apiSymbol = NormalizeCryptoSymbol(symbol);
|
|
|
|
// Margine del 50% per compensare ore notturne/festive senza candele
|
|
DateTime end = DateTime.UtcNow;
|
|
DateTime start = CalculateStartTime(end, timeframe, (int)(barCount * 1.5));
|
|
|
|
string tf = BarTimeFrameToString(timeframe);
|
|
string startStr = start.ToString("yyyy-MM-ddTHH:mm:ssZ");
|
|
string endStr = end.ToString("yyyy-MM-ddTHH:mm:ssZ");
|
|
|
|
var allBars = new List<IBar>();
|
|
string nextToken = null;
|
|
|
|
do
|
|
{
|
|
string url = string.Format(
|
|
"{0}/v1beta3/crypto/us/bars?symbols={1}&timeframe={2}&start={3}&end={4}&limit=1000&sort=asc",
|
|
CryptoDataBaseUrl,
|
|
Uri.EscapeDataString(apiSymbol),
|
|
tf,
|
|
Uri.EscapeDataString(startStr),
|
|
Uri.EscapeDataString(endStr));
|
|
|
|
if (nextToken != null)
|
|
url += "&page_token=" + Uri.EscapeDataString(nextToken);
|
|
|
|
using (var reqMsg = new HttpRequestMessage(HttpMethod.Get, url))
|
|
{
|
|
reqMsg.Headers.Add("APCA-API-KEY-ID", _apiKey);
|
|
reqMsg.Headers.Add("APCA-API-SECRET-KEY", _apiSecret);
|
|
reqMsg.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
|
|
|
|
HttpResponseMessage resp = await _httpClient.SendAsync(reqMsg).ConfigureAwait(false);
|
|
string json = await resp.Content.ReadAsStringAsync().ConfigureAwait(false);
|
|
|
|
if (!resp.IsSuccessStatusCode)
|
|
throw new InvalidOperationException(
|
|
string.Format("Alpaca crypto bars API error {0}: {1}", (int)resp.StatusCode, json));
|
|
|
|
JObject root = JObject.Parse(json);
|
|
nextToken = root["next_page_token"]?.Value<string>();
|
|
|
|
JToken barsToken = root["bars"]?[apiSymbol];
|
|
if (barsToken != null)
|
|
{
|
|
foreach (JToken b in barsToken)
|
|
{
|
|
allBars.Add(new SimpleBar
|
|
{
|
|
Symbol = apiSymbol,
|
|
TimeUtc = b["t"].Value<DateTime>().ToUniversalTime(),
|
|
Open = b["o"].Value<decimal>(),
|
|
High = b["h"].Value<decimal>(),
|
|
Low = b["l"].Value<decimal>(),
|
|
Close = b["c"].Value<decimal>(),
|
|
Volume = b["v"].Value<decimal>(),
|
|
Vwap = b["vw"] != null ? b["vw"].Value<decimal>() : 0m,
|
|
TradeCount = b["n"] != null ? (ulong)b["n"].Value<long>() : 0UL
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
while (nextToken != null && allBars.Count < barCount * 2);
|
|
|
|
// Restituisce le ultime barCount barre (le più recenti)
|
|
if (allBars.Count > barCount)
|
|
return allBars.Skip(allBars.Count - barCount).ToList();
|
|
return allBars;
|
|
}
|
|
|
|
private static string NormalizeCryptoSymbol(string symbol)
|
|
{
|
|
if (symbol.Equals("BTCUSD", StringComparison.OrdinalIgnoreCase)) return "BTC/USD";
|
|
if (symbol.Equals("ETHUSD", StringComparison.OrdinalIgnoreCase)) return "ETH/USD";
|
|
return symbol;
|
|
}
|
|
|
|
private static string BarTimeFrameToString(BarTimeFrame timeframe)
|
|
{
|
|
if (timeframe == BarTimeFrame.Minute) return "1Min";
|
|
if (timeframe == BarTimeFrame.Hour) return "1Hour";
|
|
if (timeframe == BarTimeFrame.Day) return "1Day";
|
|
return timeframe.ToString();
|
|
}
|
|
|
|
private static DateTime CalculateStartTime(DateTime end, BarTimeFrame timeframe, int count)
|
|
{
|
|
if (timeframe == BarTimeFrame.Minute) return end.AddMinutes(-count);
|
|
if (timeframe == BarTimeFrame.Hour) return end.AddHours(-count);
|
|
return end.AddDays(-count);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Piazza un ordine bracket con Take Profit e Stop Loss.
|
|
/// Conforme alla documentazione Alpaca: MarketOrder + TakeProfit + StopLoss.
|
|
/// </summary>
|
|
public async Task<IOrder> PlaceBracketOrderAsync(string symbol, decimal quantity, decimal entryPrice,
|
|
decimal takeProfitPrice, decimal stopLossPrice, OrderSide side)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "PlaceBracketOrder").ConfigureAwait(false);
|
|
|
|
// Usa OrderQuantity.Fractional per crypto (es. 0.001 BTC), intero per equity
|
|
var orderQty = quantity == Math.Floor(quantity)
|
|
? OrderQuantity.FromInt64((long)quantity)
|
|
: OrderQuantity.Fractional(quantity);
|
|
|
|
var entryOrder = side == OrderSide.Buy
|
|
? MarketOrder.Buy(symbol, orderQty)
|
|
: MarketOrder.Sell(symbol, orderQty);
|
|
|
|
var bracketOrder = entryOrder
|
|
.TakeProfit(takeProfitPrice)
|
|
.StopLoss(stopLossPrice);
|
|
|
|
return await _tradingClient.PostOrderAsync(bracketOrder);
|
|
}
|
|
|
|
public async Task<IOrder> PlaceMarketOrderAsync(string symbol, decimal quantity, OrderSide side)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "PlaceMarketOrder").ConfigureAwait(false);
|
|
var orderQty = quantity == Math.Floor(quantity)
|
|
? OrderQuantity.FromInt64((long)quantity)
|
|
: OrderQuantity.Fractional(quantity);
|
|
var order = side == OrderSide.Buy
|
|
? MarketOrder.Buy(symbol, orderQty)
|
|
: MarketOrder.Sell(symbol, orderQty);
|
|
order.Duration = TimeInForce.Gtc;
|
|
order.ClientOrderId = "BOT_" + Guid.NewGuid().ToString("N").Substring(0, 16);
|
|
return await _tradingClient.PostOrderAsync(order);
|
|
}
|
|
|
|
public async Task<IOrder> PlaceStopOrderAsync(string symbol, decimal quantity, decimal stopPrice, OrderSide side)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "PlaceStopOrder").ConfigureAwait(false);
|
|
var orderQty = quantity == Math.Floor(quantity)
|
|
? OrderQuantity.FromInt64((long)quantity)
|
|
: OrderQuantity.Fractional(quantity);
|
|
var order = side == OrderSide.Buy
|
|
? StopOrder.Buy(symbol, orderQty, stopPrice)
|
|
: StopOrder.Sell(symbol, orderQty, stopPrice);
|
|
order.Duration = TimeInForce.Gtc;
|
|
order.ClientOrderId = "BOT_" + Guid.NewGuid().ToString("N").Substring(0, 16);
|
|
return await _tradingClient.PostOrderAsync(order);
|
|
}
|
|
|
|
public async Task<IOrder> PlaceLimitOrderAsync(string symbol, decimal quantity, decimal limitPrice, OrderSide side)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "PlaceLimitOrder").ConfigureAwait(false);
|
|
var orderQty = quantity == Math.Floor(quantity)
|
|
? OrderQuantity.FromInt64((long)quantity)
|
|
: OrderQuantity.Fractional(quantity);
|
|
var order = side == OrderSide.Buy
|
|
? LimitOrder.Buy(symbol, orderQty, limitPrice)
|
|
: LimitOrder.Sell(symbol, orderQty, limitPrice);
|
|
order.Duration = TimeInForce.Gtc;
|
|
order.ClientOrderId = "BOT_" + Guid.NewGuid().ToString("N").Substring(0, 16);
|
|
return await _tradingClient.PostOrderAsync(order);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica se esiste una posizione aperta per un simbolo.
|
|
/// Il codice 40410000 indica assenza di posizione (non è un errore reale).
|
|
/// </summary>
|
|
public async Task<bool> HasOpenPositionAsync(string symbol)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "HasOpenPosition").ConfigureAwait(false);
|
|
try
|
|
{
|
|
IPosition position = await _tradingClient.GetPositionAsync(symbol);
|
|
return position != null && Math.Abs(position.Quantity) > 0;
|
|
}
|
|
catch (RestClientErrorException ex) when (ex.ErrorCode == 40410000)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera la posizione aperta per un simbolo specifico.
|
|
/// Ritorna null se non esiste (codice 40410000 = no position).
|
|
/// </summary>
|
|
public async Task<IPosition> GetPositionAsync(string symbol)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "GetPosition").ConfigureAwait(false);
|
|
try
|
|
{
|
|
return await _tradingClient.GetPositionAsync(symbol);
|
|
}
|
|
catch (RestClientErrorException ex) when (ex.ErrorCode == 40410000)
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera tutte le posizioni aperte.
|
|
/// </summary>
|
|
public async Task<IReadOnlyList<IPosition>> GetAllPositionsAsync()
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "GetAllPositions").ConfigureAwait(false);
|
|
return await _tradingClient.ListPositionsAsync();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera l'ultimo prezzo disponibile per un simbolo.
|
|
/// Per crypto usa IAlpacaCryptoDataClient.GetLatestBarAsync (endpoint /v1beta3/crypto/us/latest/bars).
|
|
/// Per equity usa IAlpacaDataClient.GetLatestTradeAsync con feed IEX.
|
|
/// </summary>
|
|
public async Task<decimal> GetLatestPriceAsync(string symbol)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.MarketData, "GetLatestPrice").ConfigureAwait(false);
|
|
|
|
bool isCrypto = symbol.Contains("/") ||
|
|
symbol.Equals("BTCUSD", StringComparison.OrdinalIgnoreCase) ||
|
|
symbol.Equals("BTC/USD", StringComparison.OrdinalIgnoreCase);
|
|
|
|
if (isCrypto)
|
|
{
|
|
string apiSymbol = NormalizeCryptoSymbol(symbol);
|
|
// ListLatestBarsAsync restituisce un dizionario symbol -> IBar
|
|
var listRequest = new LatestDataListRequest(new[] { apiSymbol });
|
|
var barsDict = await _cryptoDataClient.ListLatestBarsAsync(listRequest).ConfigureAwait(false);
|
|
if (barsDict != null && barsDict.ContainsKey(apiSymbol))
|
|
return barsDict[apiSymbol].Close;
|
|
throw new InvalidOperationException(
|
|
string.Format("Nessun dato latest disponibile per {0}", apiSymbol));
|
|
}
|
|
|
|
// Equity: feed IEX gratuito
|
|
var request = new LatestMarketDataRequest(symbol)
|
|
{
|
|
Feed = MarketDataFeed.Iex
|
|
};
|
|
var latestTrade = await _dataClient.GetLatestTradeAsync(request).ConfigureAwait(false);
|
|
return latestTrade.Price;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera solo le posizioni aperte originate da ordini piazzati dal bot.
|
|
/// Strategia: lista gli ordini recenti (filled, lato Buy) con ClientOrderId
|
|
/// che inizia per "BOT_", ne estrae i simboli univoci e incrocia con le
|
|
/// posizioni effettivamente aperte su Alpaca.
|
|
/// </summary>
|
|
public async Task<IReadOnlyList<IPosition>> GetBotPositionsAsync()
|
|
{
|
|
EnsureInitialized();
|
|
|
|
// 1. Posizioni live
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "GetBotPositions_Pos").ConfigureAwait(false);
|
|
var allPositions = await _tradingClient.ListPositionsAsync().ConfigureAwait(false);
|
|
if (allPositions == null || allPositions.Count == 0)
|
|
return new List<IPosition>();
|
|
|
|
// 2. Ordini recenti (ultimi 500 filled) per trovare quelli del bot
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "GetBotPositions_Ord").ConfigureAwait(false);
|
|
var ordersRequest = new ListOrdersRequest
|
|
{
|
|
OrderStatusFilter = OrderStatusFilter.Closed,
|
|
LimitOrderNumber = 500
|
|
};
|
|
IReadOnlyList<IOrder> recentOrders;
|
|
try
|
|
{
|
|
recentOrders = await _tradingClient.ListOrdersAsync(ordersRequest).ConfigureAwait(false);
|
|
}
|
|
catch
|
|
{
|
|
// In caso di errore fallback: restituisce tutte le posizioni
|
|
return allPositions;
|
|
}
|
|
|
|
// 3. Simboli con almeno un ordine Buy filled piazzato dal bot
|
|
var botSymbols = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
|
foreach (var o in recentOrders)
|
|
{
|
|
if (o.OrderSide == OrderSide.Buy &&
|
|
o.OrderStatus == OrderStatus.Filled &&
|
|
o.ClientOrderId != null &&
|
|
o.ClientOrderId.StartsWith("BOT_", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
botSymbols.Add(o.Symbol);
|
|
}
|
|
}
|
|
|
|
if (botSymbols.Count == 0)
|
|
{
|
|
// Nessun ordine bot trovato: fallback su tutte le posizioni
|
|
// (compatibilità con posizioni aperte prima dell'introduzione del prefisso)
|
|
return allPositions;
|
|
}
|
|
|
|
// 4. Filtra le posizioni per i simboli del bot
|
|
var botPositions = new List<IPosition>();
|
|
foreach (var p in allPositions)
|
|
{
|
|
if (botSymbols.Contains(p.Symbol))
|
|
botPositions.Add(p);
|
|
}
|
|
|
|
return botPositions;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chiude tutte le posizioni aperte.
|
|
/// </summary>
|
|
public async Task CloseAllPositionsAsync()
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "CloseAllPositions").ConfigureAwait(false);
|
|
await _tradingClient.DeleteAllPositionsAsync();
|
|
}
|
|
|
|
public async Task<IReadOnlyList<IOrder>> GetOrdersAsync(OrderStatusFilter statusFilter = OrderStatusFilter.Open, int limit = 50)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "GetOrders").ConfigureAwait(false);
|
|
var request = new ListOrdersRequest
|
|
{
|
|
OrderStatusFilter = statusFilter,
|
|
LimitOrderNumber = limit
|
|
};
|
|
return await _tradingClient.ListOrdersAsync(request);
|
|
}
|
|
|
|
public async Task CancelOrderAsync(Guid orderId)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "CancelOrder").ConfigureAwait(false);
|
|
await _tradingClient.CancelOrderAsync(orderId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Chiude una singola posizione per simbolo (DELETE /v2/positions/{symbol}).
|
|
/// Ignora silenziosamente se la posizione non esiste già (già chiusa).
|
|
/// </summary>
|
|
public async Task ClosePositionAsync(string symbol)
|
|
{
|
|
EnsureInitialized();
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "ClosePosition").ConfigureAwait(false);
|
|
try
|
|
{
|
|
await _tradingClient.DeletePositionAsync(new DeletePositionRequest(symbol));
|
|
}
|
|
catch (Alpaca.Markets.RestClientErrorException ex) when (ex.Message.Contains("not found"))
|
|
{
|
|
// Posizione già chiusa o non esiste; ok
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cerca asset tradabili per simbolo o nome (case-insensitive, starts-with / contains).
|
|
/// Usa ListAssetsAsync con AssetStatus.Active + AssetClass.UsEquity o Crypto.
|
|
/// La ricerca viene effettuata localmente sul risultato della lista asset.
|
|
/// </summary>
|
|
public async Task<List<AssetSearchResult>> SearchAssetsAsync(string query, int maxResults = 20)
|
|
{
|
|
EnsureInitialized();
|
|
if (string.IsNullOrWhiteSpace(query))
|
|
return new List<AssetSearchResult>();
|
|
|
|
await ApiCounter.ThrottleAsync(ApiCategory.Trading, "SearchAssets").ConfigureAwait(false);
|
|
|
|
var request = new AssetsRequest { AssetStatus = AssetStatus.Active };
|
|
var assets = await _tradingClient.ListAssetsAsync(request).ConfigureAwait(false);
|
|
|
|
var q = query.Trim().ToUpperInvariant();
|
|
|
|
return assets
|
|
.Where(a => a.IsTradable &&
|
|
(a.Symbol.StartsWith(q, StringComparison.OrdinalIgnoreCase) ||
|
|
(a.Name != null && a.Name.IndexOf(q, StringComparison.OrdinalIgnoreCase) >= 0)))
|
|
.OrderBy(a => a.Symbol.StartsWith(q, StringComparison.OrdinalIgnoreCase) ? 0 : 1)
|
|
.ThenBy(a => a.Symbol)
|
|
.Take(maxResults)
|
|
.Select(a => new AssetSearchResult
|
|
{
|
|
Symbol = a.Symbol,
|
|
Name = a.Name ?? a.Symbol,
|
|
AssetClass = a.Class.ToString(),
|
|
Exchange = a.Exchange.ToString(),
|
|
Tradable = a.IsTradable
|
|
})
|
|
.ToList();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica che il servizio sia stato inizializzato
|
|
/// </summary>
|
|
private void EnsureInitialized()
|
|
{
|
|
if (!_isInitialized)
|
|
{
|
|
throw new InvalidOperationException("Il servizio non è stato inizializzato. Chiamare Initialize() prima di usarlo.");
|
|
}
|
|
}
|
|
}
|
|
}
|