private void intervalCb_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (intervalCb.SelectedItem != null)
{
string selectedstring = (string)intervalCb.SelectedItem;
CandleInterval intervalToUse = CandleInterval.Day1;
if (selectedstring == "1 Minute")
{
intervalToUse = CandleInterval.Minute1;
}
else if (selectedstring == "5 Minutes")
{
intervalToUse = CandleInterval.Minutes5;
}
else if (selectedstring == "1 Hour")
{
intervalToUse = CandleInterval.Hour1;
}
else if (selectedstring == "1 Day")
{
intervalToUse = CandleInterval.Day1;
}
LoadChart(coinsCb.SelectedItem.ToString(), intervalToUse);
}
}
public async Task <bool> IsSubscribed(string classCode, string securityCode, CandleInterval interval)
{
var message = new Message <string>(classCode + "|" + securityCode + "|" + (int)interval, "is_subscribed");
Message <bool> response = await QuikService.Send <Message <bool> >(message);
return(response.Data);
}
public async Task <ApiResponse> StockCandles(string code, DateTime from, CandleInterval interval)
{
var dateString = from.ToString("yyyy-MM-dd");
var url = $"http://iss.moex.com/iss/engines/stock/markets/shares/securities/{code}/candles.json?from={dateString}&interval={(int)interval}&iss.meta=off";
return(await RequestTo(url));
}
public static CandlePeriod ToOuterFormat(CandleInterval candleInterval)
{
switch (candleInterval)
{
case CandleInterval.Minute:
return(CandlePeriod.Minute1);
case CandleInterval.ThreeMinutes:
return(CandlePeriod.Minute3);
case CandleInterval.FiveMinutes:
return(CandlePeriod.Minute5);
case CandleInterval.QuarterHour:
return(CandlePeriod.Minute15);
case CandleInterval.HalfHour:
return(CandlePeriod.Minute30);
case CandleInterval.Hour:
return(CandlePeriod.Hour1);
case CandleInterval.Day:
return(CandlePeriod.Day1);
case CandleInterval.Week:
return(CandlePeriod.Day7);
case CandleInterval.Month:
return(CandlePeriod.Month1);
default:
throw new ConnectorException("Undefined candle period", null);
}
}
public static string ConvertToString(this CandleInterval interval)
{
switch (interval)
{
case CandleInterval.Minute:
return("1MIN");
case CandleInterval.Minutes5:
return("5MIN");
case CandleInterval.Minutes15:
return("15MIN");
case CandleInterval.Minutes30:
return("30MIN");
case CandleInterval.Hour:
return("1HR");
case CandleInterval.Day:
return("1D");
default:
return("unexpected");
}
}
public Settings()
{
robotMode = "Виртуальный";
lifeTimeOrder = "00:01:00";
tF = CandleInterval.M1;
koefSlip = 1;
qtyOrder = 5000;
periodPriceChnl = 5;
}
public SubscribeCandleMessage(string figi, CandleInterval interval)
{
if (string.IsNullOrWhiteSpace(figi))
{
throw new ArgumentNullException(nameof(figi));
}
Figi = figi;
Interval = interval;
}
public async Task <CandlesResponse> GetCandles(string symbol, CandleInterval interval, DateTime start, DateTime end, int limit)
{
IDictionary <string, object> form = new Dictionary <string, object>(3)
{
["start"] = UnixTime.Get(start),
["end"] = UnixTime.Get(end),
["limit"] = limit
};
return(await this.Send <CandlesResponse>($"/klines/{symbol}/{this.ConvertToString(interval)}"));
}
public override async Task <ExecutionResult> RunAsync(IStepExecutionContext context)
{
var req = StreamingRequest.SubscribeCandle(
"BBG006L8G4H1" /* YNDX */,
CandleInterval.Minute()
);
await Proxy.SendStreamingRequestAsync(req);
Console.WriteLine($"{nameof(RunWatchers)} - OK.");
return(ExecutionResult.Next());
}
public async Task <CandleList> MarketCandlesAsync(string figi, DateTime from, DateTime to,
CandleInterval interval)
{
var endpoint = AppendQueryParams(Endpoints.MarketCandles,
("figi", figi),
("from", FormatDateTime(from)),
("to", FormatDateTime(to)),
("interval", interval.GetEnumMemberValue()));
var response = await Connection.SendGetRequestAsync <CandleList>(endpoint)
.ConfigureAwait(false);
return(response?.Payload);
}
public string ConvertToString(CandleInterval candleInterval)
{
switch (candleInterval)
{
case CandleInterval.None:
return(string.Empty);
case CandleInterval.OneMinute:
return("1m");
case CandleInterval.FiveMinutes:
return("5m");
case CandleInterval.FifteenMinutes:
return("15m");
case CandleInterval.ThirtyMinutes:
return("30m");
case CandleInterval.OneHour:
return("1h");
case CandleInterval.TwoHours:
return("2h");
case CandleInterval.FourHours:
return("4h");
case CandleInterval.EightHours:
return("8h");
case CandleInterval.TwelveHours:
return("12h");
case CandleInterval.OneDay:
return("1d");
case CandleInterval.OneWeek:
return("1w");
case CandleInterval.OneMonth:
return("1m");
case CandleInterval.OneYear:
return("1y");
default:
return(string.Empty);
}
}
public static TimeSpan GetMaxPeriod(CandleInterval interval)
{
return(interval switch
{
CandleInterval.Minute => TimeSpan.FromDays(1),
CandleInterval.FiveMinutes => TimeSpan.FromDays(1),
CandleInterval.QuarterHour => TimeSpan.FromDays(1),
CandleInterval.HalfHour => TimeSpan.FromDays(1),
CandleInterval.Hour => TimeSpan.FromDays(7).Add(TimeSpan.FromHours(-1)),
CandleInterval.Day => TimeSpan.FromDays(364),
CandleInterval.Week => TimeSpan.FromDays(364 * 2),
CandleInterval.Month => TimeSpan.FromDays(364 * 10),
_ => throw new KeyNotFoundException(),
});
async Task GetQuotation(Tool instrument, CandleInterval tf)
{
List <Candle> AllCandles;
string InstrID;
toolCandles = new DataSet();
try
{
bool _isSubscribed = false;
while (!_isSubscribed)
{
textBoxLogs.AppendText("Подписываемся на получение свечек: " + instrument.ClassCode + "|" + instrument.SecurityCode + "|" + tf + "..." + Environment.NewLine);
_quik.Candles.Subscribe(instrument.ClassCode, instrument.SecurityCode, tf).Wait();
textBoxLogs.AppendText("Проверяем состояние подписки" + "..." + Environment.NewLine);
_isSubscribed = _quik.Candles.IsSubscribed(instrument.ClassCode, instrument.SecurityCode, tf).Result;
}
textBoxLogs.AppendText("Подписка включена" + "..." + Environment.NewLine);
textBoxLogs.AppendText("Получаем таблицу свечей" + "..." + Environment.NewLine);
AllCandles = await _quik.Candles.GetAllCandles(instrument.ClassCode, instrument.SecurityCode, tf).ConfigureAwait(false);
InstrID = instrument.ClassCode + "|" + instrument.SecurityCode + "|" + tf;
if (toolCandles.Tables[InstrID] == null && AllCandles.Count > 1)
{
try
{
toolCandles.Tables.Add(AllCandles_to_Table(AllCandles, InstrID));
toolCandles.Tables[InstrID].Columns["DateTime"].SetOrdinal(0);
toolCandles.Tables[InstrID].Columns["Open"].SetOrdinal(1);
toolCandles.Tables[InstrID].Columns["High"].SetOrdinal(2);
toolCandles.Tables[InstrID].Columns["Low"].SetOrdinal(3);
toolCandles.Tables[InstrID].Columns["Close"].SetOrdinal(4);
toolCandles.Tables[InstrID].Columns["Volume"].SetOrdinal(5);
textBoxLogs.AppendText("Сформирована таблица котировок для: " + InstrID + ". Количество свечек = " + AllCandles.Count + "..." + Environment.NewLine);
}
catch
{
textBoxLogs.AppendText("Не удалось сформировать таблицу котировок для: " + InstrID + "..." + Environment.NewLine);
}
}
_quik.Candles.NewCandle += OnNewCandle;
}
catch
{
textBoxLogs.AppendText("Ошибка подписки на инструмент." + Environment.NewLine);
}
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="symbol"></param>
/// <param name="interval"></param>
/// <param name="limit"></param>
/// <param name="token"></param>
/// <returns></returns>
public static async Task <string> GetLatestCandlesAsync(this ICryptocoreHttpClient client, Symbol symbol,
CandleInterval interval, int limit = 100, CancellationToken token = default)
{
Throw.IfNull(client, nameof(client));
Throw.IfNull(symbol, nameof(symbol));
var request = new CryptocoreHttpRequest($"/v1/data/ohlcv/{symbol}/latest");
request.AddParameter("period_id", interval.ConvertToString());
if (limit > 0)
{
request.AddParameter("limit", limit);
}
return(await client.GetAsync(request, token)
.ConfigureAwait(false));
}
public CandlePayload(string figi,
[JsonProperty("o")] double open,
[JsonProperty("c")] double close,
[JsonProperty("h")] double high,
[JsonProperty("l")] double low,
[JsonProperty("v")] double volume,
DateTimeOffset time,
CandleInterval interval)
{
Figi = figi;
Open = open;
Close = close;
High = high;
Low = low;
Volume = volume;
Time = time;
Interval = interval;
}
public CandlePayload(
[JsonProperty("o")] decimal open,
[JsonProperty("c")] decimal close,
[JsonProperty("h")] decimal high,
[JsonProperty("l")] decimal low,
[JsonProperty("v")] decimal volume,
DateTime time,
CandleInterval interval,
string figi)
{
Open = open;
Close = close;
High = high;
Low = low;
Volume = volume;
Time = time;
Interval = interval;
Figi = figi;
}
public CandlePayload(
decimal open,
decimal close,
decimal high,
decimal low,
decimal volume,
DateTime time,
CandleInterval interval,
string figi)
{
Open = open;
Close = close;
High = high;
Low = low;
Volume = volume;
Time = time;
Interval = interval;
Figi = figi;
}
/// <summary>
///
/// </summary>
/// <param name="client"></param>
/// <param name="symbol"></param>
/// <param name="interval"></param>
/// <param name="start"></param>
/// <param name="end"></param>
/// <param name="token"></param>
/// <returns></returns>
public static async Task <string> GetHistoricalCandlesAsync(this ICryptocoreHttpClient client, Symbol symbol,
CandleInterval interval, DateTime start, DateTime end = default,
CancellationToken token = default)
{
Throw.IfNull(client, nameof(client));
Throw.IfNull(symbol, nameof(symbol));
var request = new CryptocoreHttpRequest($"/v1/data/ohlcv/{symbol}/history");
request.AddParameter("period_id", interval.ConvertToString());
request.AddParameter("time_start", start.ToTimestamp());
if (end != default)
{
request.AddParameter("time_end", end.ToTimestamp());
}
return(await client.GetAsync(request, token)
.ConfigureAwait(false));
}
public static CandleRequest UnsubscribeCandle(string figi, CandleInterval interval) => CandleRequest.Unsubscribe(figi, interval);
private void LoadSettings()
{
disableEvents = true;
cbCandleIntervall.SelectedItem = (CandleInterval)Settings.getInt(SettKeys.CANDLE_INTERVALL);
candleInter = (CandleInterval)Settings.getInt(SettKeys.CANDLE_INTERVALL);
if (candleInter <= 0) candleInter = CandleInterval._1h;
nudMaxChartPoints.Value = Settings.getInt(SettKeys.MAX_CHART_POINTS);
foreach (string key in Settings.Data.Keys) {
if (key.StartsWith(Lib.Const.IDS.TEXTBOX)) {
string tbname = key.Substring(Lib.Const.IDS.TEXTBOX.Length);
Control[] tb = this.Controls.Find(tbname, true);
foreach (Control item in tb) {
item.Text = Lib.Converter.toString(Settings.Data[key]);
}
} else if (key.StartsWith(Lib.Const.IDS.CHECKBOX)) {
string tbname = key.Substring(Lib.Const.IDS.CHECKBOX.Length);
Control[] tb = this.Controls.Find(tbname, true);
foreach (Control item in tb) {
if (item is CheckBox) {
((CheckBox)item).Checked = Settings.getBool(key);
}
}
}
}
if (cbAutoLoadTickerApi.Checked) {
bApiLoad_Click(null, null);
}
if (cbAutoLoadTrader.Checked) {
bReloadTrader_Click(null, null);
}
if (cbAutoLoadSimPorto.Checked) {
bSetSimPorto_Click(null, null);
}
disableEvents = false;
}
private void changeCandleIntervall(CandleInterval newintervall)
{
if (newintervall == candleInter) return;
candleInter = newintervall;
if (tr != null) tr.init(kh, candleInter, cm);
cm.CandleList[(int)candleInter].setCandleEventHandler(new NewCandleEventHandler(OnNewCandleReceived));
Settings.set(SettKeys.CANDLE_INTERVALL, (int)candleInter);
}
public Indikators(CandleManager cm, CandleInterval defaultci)
{
this._cm = cm;
this._defaultci = defaultci;
}
public async Task <List <StockCandle> > StockCandles(string ticket, DateTime from, CandleInterval interval)
{
var data = await _marketData.GetStockCandleData(ticket, from, interval);
var openIndex = data.candles.columns.IndexOf("open");
var closeIndex = data.candles.columns.IndexOf("close");
var highIndex = data.candles.columns.IndexOf("high");
var lowIndex = data.candles.columns.IndexOf("low");
var valueIndex = data.candles.columns.IndexOf("value");
var volumeIndex = data.candles.columns.IndexOf("volume");
var dateTimeIndex = data.candles.columns.IndexOf("begin");
var candles = new List <StockCandle>();
foreach (var candleData in data.candles.data)
{
candles.Add(new StockCandle()
{
Open = candleData[openIndex].GetDouble(),
Close = candleData[closeIndex].GetDouble(),
High = candleData[highIndex].GetDouble(),
Low = candleData[lowIndex].GetDouble(),
Value = candleData[valueIndex].GetDouble(),
Volume = candleData[volumeIndex].GetDouble(),
DateTime = DateTime.Parse(candleData[dateTimeIndex].GetString()),
});
}
return(candles);
}
public async void Unsubscribe(string classCode, string securityCode, CandleInterval interval)
{
var message = new Message <string>(classCode + "|" + securityCode + "|" + (int)interval, "unsubscribe_from_candles");
await QuikService.Send <Message <string> >(message);
}
/// <summary>
/// Возвращает заданное количество свечек указанного инструмента и интервала с конца.
/// </summary>
/// <param name="classCode">Класс инструмента.</param>
/// <param name="securityCode">Код инструмента.</param>
/// <param name="interval">Интервал свечей.</param>
/// <param name="count">Количество возвращаемых свечей с конца.</param>
/// <returns>Список свечей.</returns>
public async Task<List<Candle>> GetLastCandles(string classCode, string securityCode, CandleInterval interval, int count)
{
var message = new Message<string>(classCode + "|" + securityCode + "|" + (int)interval + "|" + count, "get_candles_from_data_source");
Message<List<Candle>> response = await QuikService.Send<Message<List<Candle>>>(message);
return response.Data;
}
public static CandleUnsubscribeRequest UnsubscribeCandle(string figi, CandleInterval interval)
{
return(new CandleUnsubscribeRequest(figi, interval));
}
public CandleUnsubscribeRequest(string figi, CandleInterval interval, string requestId = null)
: base(requestId)
{
Figi = figi;
Interval = interval;
}
public void init(ApiHelp kh, CandleInterval ci, CandleManager cm)
{
this._api = kh;
this._ci = ci;
this._data = new Indikators(cm, ci);
this._cm = cm;
}
private void LoadChart(string symbol, CandleInterval interval)
{
CurrentLoadedSymbol = symbol;
CurrentInterval = interval;
//client.SetApiCredentials("118180a6a91e29425c90c2e2afe349aa71", "e36a6307025c4b4fb1b20a4a00c4c9ef");
client.SetApiCredentials(Key, Secret);
//get min trade size
var markets = client.GetSymbols();
if (markets.Data != null)
{
var market = markets.Data.FirstOrDefault(l => l.Symbol == symbol);
CurrentMinTradeSize = market.MinTradeSize;
}
//get high low data
var summary = client.GetSymbolSummary(symbol);
if (summary.Data != null)
{
CurrentPriceHigh = summary.Data.High;
CurrentPriceLow = summary.Data.Low;
}
//get balance for currency
var balance = client.GetBalance(symbol.Substring(0, 3));
if (balance.Data != null)
{
AccountBalance = balance.Data.Available.ToString() + " " + balance.Data.Currency;
}
//get order history
var orderhistory = client.GetOrderBook(symbol);
if (orderhistory.Data != null)
{
OrderBook = orderhistory.Data;
}
//get closed orders
var d = client.GetClosedOrders(symbol);
if (d.Data != null)
{
ClosedOrders = new ObservableCollection <BittrexOrderV3>(d.Data);
}
//get open orders
var o = client.GetOpenOrders(symbol);
if (o.Data != null)
{
OpenOrders = new ObservableCollection <BittrexOrderV3>(o.Data);
}
//var balance = client.GetBalance(CurrentLoadedSymbol);
//if (balance.Data != null)
//{
// AccountBalance = balance.Data.Total.ToString();
//}
//else
//{
// AccountBalance = "0.00";
//}
string intervalstring = "";
if (interval == CandleInterval.Day1)
{
intervalstring = "DAY_1";
}
else if (interval == CandleInterval.Hour1)
{
intervalstring = "HOUR_1";
}
else if (interval == CandleInterval.Minute1)
{
intervalstring = "MINUTE_1";
}
else if (interval == CandleInterval.Minutes5)
{
intervalstring = "MINUTE_5";
}
var coincandledatajson = CallRestMethod("https://api.bittrex.com/v3/markets/" + symbol + "/candles/" + intervalstring + "/recent");
var coincandledata = JsonConvert.DeserializeObject <CandleData[]>(coincandledatajson);
coinsCb.SelectedItem = symbol; //defualt
foreach (CandleData candle in coincandledata)
{
candle.Time = candle.StartsAt.DateTime;
}
if (plotmodel != null)
{
plotmodel.Series.Clear();
}
OxyPlot.PlotModel model = new OxyPlot.PlotModel();
//x
model.Axes.Add(new DateTimeAxis
{
//StringFormat = "hh:mm",
Title = "Time",
AxislineColor = OxyColors.White,
TitleColor = OxyColors.White,
TicklineColor = OxyColors.White,
TextColor = OxyColors.White,
MinorIntervalType = DateTimeIntervalType.Auto,
Position = AxisPosition.Bottom,
});
XAxis = model.Axes[0];
//y
model.Axes.Add(new LinearAxis()
{
Title = "Market Price",
Position = AxisPosition.Left,
AxislineColor = OxyColors.White,
TitleColor = OxyColors.White,
TicklineColor = OxyColors.White,
TextColor = OxyColors.White,
});
YAxis = model.Axes[1];
//create plot model and add the line series
CandleStickSeries data = new CandleStickSeries()
{
Title = symbol
};
data.DataFieldClose = "Close";
data.DataFieldHigh = "High";
data.DataFieldLow = "Low";
data.DataFieldOpen = "Open";
data.DataFieldX = "Time";
data.Color = OxyColors.DarkGray;
data.IncreasingColor = OxyColors.Green;
data.DecreasingColor = OxyColors.Red;
data.ItemsSource = coincandledata;
data.TrackerFormatString = "Date: {2}\nOpen: {5:0.00000}\nHigh: {3:0.00000}\nLow: {4:0.00000}\nClose: {6:0.00000}";
plotmodel = model;
model.PlotAreaBorderColor = OxyColors.White;
model.LegendTextColor = OxyColors.YellowGreen;
model.Series.Add(data);
model.Background = OxyColors.Black;
model.MouseUp += Model_MouseUp;;
model.MouseDown += Model_MouseDown;;
plotview.Model = model;
if (LimitLineSeries != null)
{
DrawLimitLine(OrderSide.Buy, LimitLineSeries);
}
}
public async Task <List <Candle> > GetCandlesHistory(string figi, DateTime from, DateTime to, CandleInterval candleInterval)
{
int delay = TimeDelay / RetriesCount;
int ost = TimeDelay % RetriesCount;
for (int i = 0; i < RetriesCount; i++)
{
try
{
switch (_mode)
{
case Mode.Sandbox:
var listS = await _sandboxContext.MarketCandlesAsync(figi, from, to, candleInterval);
var candles = listS.Candles.Select(x => new Candle
{
close = (double)x.Close,
figi = x.Figi,
high = (double)x.High,
interval = (CandleIntervalEnum)x.Interval,
low = (double)x.Low,
open = (double)x.Open,
time = x.Time,
volume = (double)x.Volume
}).ToList();
return(candles);
case Mode.Bourse:
var listB = await _bourseContext.MarketCandlesAsync(figi, from, to, candleInterval);
var candlesB = listB.Candles.Select(x => new Candle
{
close = (double)x.Close,
figi = x.Figi,
high = (double)x.High,
interval = (CandleIntervalEnum)x.Interval,
low = (double)x.Low,
open = (double)x.Open,
time = x.Time,
volume = (double)x.Volume
}).ToList();
return(candlesB);
default: throw new NotImplementedException();
}
}
catch
{
if (i == RetriesCount - 1)
{
delay += ost;
}
System.Threading.Thread.Sleep(delay);
}
}
throw new Exception("Error send");
}
/// <summary>
/// Функция возвращает список свечек указанного инструмента заданного интервала.
/// </summary>
/// <param name="classCode">Класс инструмента.</param>
/// <param name="securityCode">Код инструмента.</param>
/// <param name="interval">Интервал свечей.</param>
/// <returns>Список свечей.</returns>
public async Task<List<Candle>> GetAllCandles(string classCode, string securityCode, CandleInterval interval)
{
//Параметр count == 0 говорт о том, что возвращаются все доступные свечи
return await GetLastCandles(classCode, securityCode, interval, 0);
}
public async Task<bool> IsSubscribed(string classCode, string securityCode, CandleInterval interval)
{
var message = new Message<string>(classCode + "|" + securityCode + "|" + (int)interval, "is_subscribed");
Message<bool> response = await QuikService.Send<Message<bool>>(message);
return response.Data;
}
private CandleRequest(bool subscribe, string figi, CandleInterval interval)
: base(subscribe, "candle")
{
Figi = figi;
Interval = interval.Value;
}
/// <summary>
/// take candles by instrument
/// взять свечи по инструменту
/// </summary>
/// <param name="security"> short security name/короткое название бумаги</param>
/// <param name="timeSpan">timeframe/таймФрейм</param>
/// <returns>failure will return null/в случае неудачи вернётся null</returns>
public List <Candle> GetQuikLuaCandleHistory(Security security, TimeSpan timeSpan)
{
try
{
lock (_getCandlesLocker)
{
if (timeSpan.TotalMinutes > 1440 ||
timeSpan.TotalMinutes < 1)
{
return(null);
}
CandleInterval tf = CandleInterval.M5;
if (Convert.ToInt32(timeSpan.TotalMinutes) == 1)
{
tf = CandleInterval.M1;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 2)
{
tf = CandleInterval.M2;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 5)
{
tf = CandleInterval.M5;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 10)
{
tf = CandleInterval.M10;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 15)
{
tf = CandleInterval.M15;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 20)
{
tf = CandleInterval.M20;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 30)
{
tf = CandleInterval.M30;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 60)
{
tf = CandleInterval.H1;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 120)
{
tf = CandleInterval.H2;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 240)
{
tf = CandleInterval.H4;
}
else if (Convert.ToInt32(timeSpan.TotalMinutes) == 1440)
{
tf = CandleInterval.D1;
}
#region MyRegion
_candles = null;
var needSec = security;
if (needSec != null)
{
_candles = new List <Candle>();
string classCode = needSec.NameClass;
var allCandlesForSec = QuikLua.Candles.GetAllCandles(classCode, needSec.Name.Split('_')[0], tf).Result;
for (int i = 0; i < allCandlesForSec.Count; i++)
{
if (allCandlesForSec[i] != null)
{
Candle newCandle = new Candle();
newCandle.Close = allCandlesForSec[i].Close;
newCandle.High = allCandlesForSec[i].High;
newCandle.Low = allCandlesForSec[i].Low;
newCandle.Open = allCandlesForSec[i].Open;
newCandle.Volume = allCandlesForSec[i].Volume;
if (i == allCandlesForSec.Count - 1)
{
newCandle.State = CandleState.None;
}
else
{
newCandle.State = CandleState.Finished;
}
newCandle.TimeStart = new DateTime(allCandlesForSec[i].Datetime.year,
allCandlesForSec[i].Datetime.month,
allCandlesForSec[i].Datetime.day,
allCandlesForSec[i].Datetime.hour,
allCandlesForSec[i].Datetime.min,
allCandlesForSec[i].Datetime.sec);
_candles.Add(newCandle);
}
}
}
#endregion
return(_candles);
}
}
catch (Exception error)
{
SendLogMessage(error.ToString(), LogMessageType.Error);
return(null);
}
}
internal static CandleRequest Unsubscribe(string figi, CandleInterval interval)
{
return(new CandleRequest(false, figi, interval));
}
public async Task <IActionResult> GetCandlesHistory(string figi, string from, string to, CandleInterval candleInterval = CandleInterval.Minute)
{
var type = "O";
var result = await _tinkoffService.GetCandlesHistory(figi, DateTime.ParseExact(from, type, CultureInfo.InvariantCulture), DateTime.ParseExact(to, type, CultureInfo.InvariantCulture), candleInterval);
return(Ok(result));
}
public async void Unsubscribe(string classCode, string securityCode, CandleInterval interval)
{
var message = new Message<string>(classCode + "|" + securityCode + "|" + (int)interval, "unsubscribe_from_candles");
await QuikService.Send<Message<string>>(message);
}
// В ассинхронных фукнциях нельзя возвращать void, вместо этого нужно возвращать Task. Иначе нельзя будет ожидать фукнцию и ловить исключения
public async Task Subscribe(string classCode, string securityCode, CandleInterval interval)
{
var message = new Message <string>(classCode + "|" + securityCode + "|" + (int)interval, "subscribe_to_candles");
await QuikService.Send <Message <string> >(message).ConfigureAwait(false);
}
