// konstruktor, wywoływany spod BosPapers.Update()
internal BosPaper(BosAccount account, DTO.Paper data)
{
Account = account;
Instrument = BosInstrument.Create(data.Instrument);
Quantity110 = data.Account110;
Quantity120 = data.Account120;
}
/// <summary>
/// Wysłanie do systemu nowego zlecenia z podanymi parametrami. W tej wersji metody numer rachunku,
/// na który zostaje przeznaczone to zlecenie, wybierany jest automatycznie na podstawie typu instrumentu.
/// <para>Zobacz też metody klasy BosInstrument: Order, Buy, Sell - które od razu określają,
/// którego instrumentu dane zlecenie ma dotyczyć i ewentualnie prezyzują też stronę transakcji (kupno/sprzedaż)</para>
/// </summary>
/// <param name="instrument">Instrument, którego walory chcemy kupić/sprzedać.</param>
/// <param name="side">Zlecenie kupna (BosOrderSide.Buy) czy sprzedaży (BosOrderSide.Sell).</param>
/// <param name="price">Limit ceny, jaki wstawiamy do zlecenia (BosPrice.PKC/PCR/PCRO... lub po prostu kwota).</param>
/// <param name="activationPrice">Ewentualny limit aktywacji zlecenia (null, jeśli aktywowane od razu, bez stop'a).</param>
/// <param name="quantity">Liczba walorów, jaką zamierzamy kupić/sprzedać.</param>
/// <param name="minimumQuantity">Minimalna liczba walorów, jaka musi się zrealizować, albo zlecenie będzie anulowane.
/// Podając tutaj to samo, co w polu "quantity", uzyskujemy zlecenie typu "WuA".</param>
/// <param name="visibleQuantity">Liczba walorów ujawniana w arkuszu ofert ("WUJ").</param>
/// <param name="immediateOrCancel">Czy to zlecenie typu "WiA" (to, co nie wykona się natychmiast, jest od razu anulowane).</param>
/// <param name="expirationDate">Data ważności zlecenia (null, jeśli tylko na bieżącą sesję).</param>
public static void Create(BosInstrument instrument,
BosOrderSide side, BosPrice price, decimal?activationPrice,
uint quantity, uint?minimumQuantity, uint?visibleQuantity, bool immediateOrCancel, DateTime?expirationDate)
{
var account = Bossa.Accounts[instrument.Type];
Create(account, instrument, side, price, activationPrice,
quantity, minimumQuantity, visibleQuantity, immediateOrCancel, expirationDate);
}
// dołącza dane z innego obiektu tego samego typu, wywoływane z klasy BosInstruments
internal void Combine(BosInstrument source)
{
ISIN = ISIN ?? source.ISIN;
Symbol = Symbol ?? source.Symbol;
Sym = GetInstrumentSym();
Type = GetInstrumentType();
BuyOffers.Combine(source.BuyOffers);
SellOffers.Combine(source.SellOffers);
Trades.Combine(source.Trades);
Session.Combine(source.Session);
}
// aktualizacja danych z sieci - podstawowe dane zlecenia
private void Update(OrderMainData data)
{
CreateTime = data.CreateTime;
Instrument = BosInstrument.Create(data.Instrument);
Side = data.Side;
Price = BosPrice.Create(data.PriceType, data.PriceLimit);
ActivationPrice = data.ActivationPrice;
Quantity = data.Quantity;
MinimumQuantity = data.MinimumQuantity;
VisibleQuantity = data.VisibleQuantity;
ImmediateOrCancel = data.ImmediateOrCancel;
ExpirationDate = data.ExpirationDate;
}
// aktualizacja informacji o bieżących notowaniach
private void MarketUpdateHandler(MarketData[] marketData)
{
var updatedInstruments = new HashSet <BosInstrument>();
foreach (var data in marketData)
{
var instrument = BosInstrument.Create(data.Instrument);
instrument.Update(data);
updatedInstruments.Add(instrument);
}
foreach (var instrument in updatedInstruments)
{
InvokeUpdate(instrument);
}
}
/// <summary>
/// Wysłanie do systemu nowego zlecenia z podanymi parametrami.
/// <para>Zobacz też metody klasy BosInstrument: Order, Buy, Sell - które od razu określają,
/// którego instrumentu dane zlecenie ma dotyczyć i ewentualnie prezyzują też stronę transakcji (kupno/sprzedaż)</para>
/// </summary>
/// <param name="account">Rachunek, na który zostaje przeznaczone to zlecenie.</param>
/// <param name="instrument">Instrument, którego walory chcemy kupić/sprzedać.</param>
/// <param name="side">Zlecenie kupna (BosOrderSide.Buy) czy sprzedaży (BosOrderSide.Sell).</param>
/// <param name="price">Limit ceny, jaki wstawiamy do zlecenia (BosPrice.PKC/PCR/PCRO... lub po prostu kwota).</param>
/// <param name="activationPrice">Ewentualny limit aktywacji zlecenia (null, jeśli aktywowane od razu, bez stop'a).</param>
/// <param name="quantity">Liczba walorów, jaką zamierzamy kupić/sprzedać.</param>
/// <param name="minimumQuantity">Minimalna liczba walorów, jaka musi się zrealizować, albo zlecenie będzie anulowane.
/// Podając tutaj to samo, co w polu "quantity", uzyskujemy zlecenie typu "WuA".</param>
/// <param name="visibleQuantity">Liczba walorów ujawniana w arkuszu ofert ("WUJ").</param>
/// <param name="immediateOrCancel">Czy to zlecenie typu "WiA" (to, co nie wykona się natychmiast, jest od razu anulowane).</param>
/// <param name="expirationDate">Data ważności zlecenia (null, jeśli tylko na bieżącą sesję).</param>
public static void Create(BosAccount account, BosInstrument instrument,
BosOrderSide side, BosPrice price, decimal?activationPrice,
uint quantity, uint?minimumQuantity, uint?visibleQuantity, bool immediateOrCancel, DateTime?expirationDate)
{
var data = new OrderData();
data.AccountNumber = account.Number;
data.MainData = new OrderMainData();
data.MainData.CreateTime = DateTime.Now;
data.MainData.Instrument = instrument.Convert();
data.MainData.Side = side;
data.MainData.PriceType = price.Type;
data.MainData.PriceLimit = price.NumValue;
data.MainData.ActivationPrice = activationPrice;
data.MainData.Quantity = quantity;
data.MainData.MinimumQuantity = minimumQuantity;
data.MainData.VisibleQuantity = visibleQuantity;
data.MainData.ImmediateOrCancel = immediateOrCancel;
data.MainData.ExpirationDate = expirationDate;
account.api.Connection.OrderCreate(data);
// TODO: Zastanawiam się jeszczcze m.in. co z ClientId, TradeDate... i czy w ogóle byłby sens
// od razu tworzyć taki nowy obiekt BosOrder (zamiast zaczekać aż sam się doda przy OrderUpdate).
}
// ----- ustawianie listview z notowaniami instrumentów -----
private void UpdateInstrumentInfo(BosInstrument instrument)
{
var item = GetInstrumentItem(instrument);
var oldText = item.Text;
item.SubItems.Clear();
item.Name = instrument.ISIN ?? instrument.Symbol;
item.Text = instrument.Symbol ?? instrument.ISIN;
var bid = instrument.BuyOffers.Best;
item.SubItems.Add((bid != null) ? bid.Volume.ToString() : "");
item.SubItems.Add((bid != null) ? bid.Price.ToString() : "");
var ask = instrument.SellOffers.Best;
item.SubItems.Add((ask != null) ? ask.Price.ToString() : "");
item.SubItems.Add((ask != null) ? ask.Volume.ToString() : "");
var trd = instrument.Trades.Last;
item.SubItems.Add((trd != null) ? trd.Quantity.ToString() : "");
item.SubItems.Add((trd != null) ? trd.Price.ToString() : "");
item.SubItems.Add((trd != null) ? trd.Time.TimeOfDay.ToString() : "");
if (item.Text != oldText) instrumentsView.Sort();
}
private ListViewItem GetInstrumentItem(BosInstrument instrument)
{
var item = instrumentsView.Items[instrument.ISIN] ??
instrumentsView.Items[instrument.Symbol];
if (item == null)
{
item = new ListViewItem();
item.Tag = instrument;
instrumentsView.Items.Add(item);
}
return item;
}
// konstruktor, wywoływany spod BosPapers.GetPaper()
// (tworzy tymczasowy obiekt z ilością papierów równą zeru)
internal BosPaper(BosInstrument instrument)
{
Instrument = instrument;
}
/// <summary>
/// Wysłanie do systemu nowego zlecenia z podanymi parametrami. W tej wersji metody numer rachunku,
/// na który zostaje przeznaczone to zlecenie, wybierany jest automatycznie na podstawie typu instrumentu.
/// <para>Zobacz też metody klasy BosInstrument: Order, Buy, Sell - które od razu określają,
/// którego instrumentu dane zlecenie ma dotyczyć i ewentualnie prezyzują też stronę transakcji (kupno/sprzedaż)</para>
/// </summary>
/// <param name="instrument">Instrument, którego walory chcemy kupić/sprzedać.</param>
/// <param name="side">Zlecenie kupna (BosOrderSide.Buy) czy sprzedaży (BosOrderSide.Sell).</param>
/// <param name="price">Limit ceny, jaki wstawiamy do zlecenia (BosPrice.PKC/PCR/PCRO... lub po prostu kwota).</param>
/// <param name="activationPrice">Ewentualny limit aktywacji zlecenia (null, jeśli aktywowane od razu, bez stop'a).</param>
/// <param name="quantity">Liczba walorów, jaką zamierzamy kupić/sprzedać.</param>
/// <param name="minimumQuantity">Minimalna liczba walorów, jaka musi się zrealizować, albo zlecenie będzie anulowane.
/// Podając tutaj to samo, co w polu "quantity", uzyskujemy zlecenie typu "WuA".</param>
/// <param name="visibleQuantity">Liczba walorów ujawniana w arkuszu ofert ("WUJ").</param>
/// <param name="immediateOrCancel">Czy to zlecenie typu "WiA" (to, co nie wykona się natychmiast, jest od razu anulowane).</param>
/// <param name="expirationDate">Data ważności zlecenia (null, jeśli tylko na bieżącą sesję).</param>
public static void Create(BosInstrument instrument,
BosOrderSide side, BosPrice price, decimal? activationPrice,
uint quantity, uint? minimumQuantity, uint? visibleQuantity, bool immediateOrCancel, DateTime? expirationDate)
{
var account = Bossa.Accounts[instrument.Type];
Create(account, instrument, side, price, activationPrice,
quantity, minimumQuantity, visibleQuantity, immediateOrCancel, expirationDate);
}
/// <summary>
/// Wysłanie do systemu nowego zlecenia z podanymi parametrami (pozostałe przyjmują
/// domyślną wartość null/false, a numer rachunku wyznaczany jest na podstawie typu instrumentu).
/// <para>Zobacz też metody klasy BosInstrument: Order, Buy, Sell - które od razu określają,
/// którego instrumentu dane zlecenie ma dotyczyć i ewentualnie prezyzują też stronę transakcji (kupno/sprzedaż)</para>
/// </summary>
/// <param name="instrument">Instrument, którego walory chcemy kupić/sprzedać.</param>
/// <param name="side">Zlecenie kupna (BosOrderSide.Buy) czy sprzedaży (BosOrderSide.Sell).</param>
/// <param name="price">Limit ceny, jaki wstawiamy do zlecenia (BosPrice.PKC/PCR/PCRO... lub po prostu kwota).</param>
/// <param name="quantity">Liczba walorów, jaką zamierzamy kupić/sprzedać.</param>
public static void Create(BosInstrument instrument, BosOrderSide side, BosPrice price, uint quantity)
{
Create(instrument, side, price, null, quantity, null, null, false, null);
}
// konstruktor, wywoływany spod BosPapers.GetPaper()
// (tworzy tymczasowy obiekt z ilością papierów równą zeru)
internal BosPaper(BosInstrument instrument)
{
Instrument = instrument;
}
/// <summary>
/// Wysłanie do systemu nowego zlecenia z podanymi parametrami (pozostałe przyjmują
/// domyślną wartość null/false, a numer rachunku wyznaczany jest na podstawie typu instrumentu).
/// <para>Zobacz też metody klasy BosInstrument: Order, Buy, Sell - które od razu określają,
/// którego instrumentu dane zlecenie ma dotyczyć i ewentualnie prezyzują też stronę transakcji (kupno/sprzedaż)</para>
/// </summary>
/// <param name="instrument">Instrument, którego walory chcemy kupić/sprzedać.</param>
/// <param name="side">Zlecenie kupna (BosOrderSide.Buy) czy sprzedaży (BosOrderSide.Sell).</param>
/// <param name="price">Limit ceny, jaki wstawiamy do zlecenia (BosPrice.PKC/PCR/PCRO... lub po prostu kwota).</param>
/// <param name="activationPrice">Ewentualny limit aktywacji zlecenia (null, jeśli aktywowane od razu, bez stop'a).</param>
/// <param name="quantity">Liczba walorów, jaką zamierzamy kupić/sprzedać.</param>
/// <param name="expirationDate">Data ważności zlecenia (null, jeśli tylko na bieżącą sesję).</param>
public static void Create(BosInstrument instrument,
BosOrderSide side, BosPrice price, decimal?activationPrice, uint quantity, DateTime?expirationDate)
{
Create(instrument, side, price, activationPrice, quantity, null, null, false, expirationDate);
}
/// <summary>
/// Wysłanie do systemu nowego zlecenia z podanymi parametrami (pozostałe przyjmują
/// domyślną wartość null/false, a numer rachunku wyznaczany jest na podstawie typu instrumentu).
/// <para>Zobacz też metody klasy BosInstrument: Order, Buy, Sell - które od razu określają,
/// którego instrumentu dane zlecenie ma dotyczyć i ewentualnie prezyzują też stronę transakcji (kupno/sprzedaż)</para>
/// </summary>
/// <param name="instrument">Instrument, którego walory chcemy kupić/sprzedać.</param>
/// <param name="side">Zlecenie kupna (BosOrderSide.Buy) czy sprzedaży (BosOrderSide.Sell).</param>
/// <param name="price">Limit ceny, jaki wstawiamy do zlecenia (BosPrice.PKC/PCR/PCRO... lub po prostu kwota).</param>
/// <param name="activationPrice">Ewentualny limit aktywacji zlecenia (null, jeśli aktywowane od razu, bez stop'a).</param>
/// <param name="quantity">Liczba walorów, jaką zamierzamy kupić/sprzedać.</param>
/// <param name="expirationDate">Data ważności zlecenia (null, jeśli tylko na bieżącą sesję).</param>
public static void Create(BosInstrument instrument,
BosOrderSide side, BosPrice price, decimal? activationPrice, uint quantity, DateTime? expirationDate)
{
Create(instrument, side, price, activationPrice, quantity, null, null, false, expirationDate);
}
/// <summary>
/// Wysłanie do systemu nowego zlecenia z podanymi parametrami.
/// <para>Zobacz też metody klasy BosInstrument: Order, Buy, Sell - które od razu określają,
/// którego instrumentu dane zlecenie ma dotyczyć i ewentualnie prezyzują też stronę transakcji (kupno/sprzedaż)</para>
/// </summary>
/// <param name="account">Rachunek, na który zostaje przeznaczone to zlecenie.</param>
/// <param name="instrument">Instrument, którego walory chcemy kupić/sprzedać.</param>
/// <param name="side">Zlecenie kupna (BosOrderSide.Buy) czy sprzedaży (BosOrderSide.Sell).</param>
/// <param name="price">Limit ceny, jaki wstawiamy do zlecenia (BosPrice.PKC/PCR/PCRO... lub po prostu kwota).</param>
/// <param name="activationPrice">Ewentualny limit aktywacji zlecenia (null, jeśli aktywowane od razu, bez stop'a).</param>
/// <param name="quantity">Liczba walorów, jaką zamierzamy kupić/sprzedać.</param>
/// <param name="minimumQuantity">Minimalna liczba walorów, jaka musi się zrealizować, albo zlecenie będzie anulowane.
/// Podając tutaj to samo, co w polu "quantity", uzyskujemy zlecenie typu "WuA".</param>
/// <param name="visibleQuantity">Liczba walorów ujawniana w arkuszu ofert ("WUJ").</param>
/// <param name="immediateOrCancel">Czy to zlecenie typu "WiA" (to, co nie wykona się natychmiast, jest od razu anulowane).</param>
/// <param name="expirationDate">Data ważności zlecenia (null, jeśli tylko na bieżącą sesję).</param>
public static void Create(BosAccount account, BosInstrument instrument,
BosOrderSide side, BosPrice price, decimal? activationPrice,
uint quantity, uint? minimumQuantity, uint? visibleQuantity, bool immediateOrCancel, DateTime? expirationDate)
{
var data = new OrderData();
data.AccountNumber = account.Number;
data.MainData = new OrderMainData();
data.MainData.CreateTime = DateTime.Now;
data.MainData.Instrument = instrument.Convert();
data.MainData.Side = side;
data.MainData.PriceType = price.Type;
data.MainData.PriceLimit = price.NumValue;
data.MainData.ActivationPrice = activationPrice;
data.MainData.Quantity = quantity;
data.MainData.MinimumQuantity = minimumQuantity;
data.MainData.VisibleQuantity = visibleQuantity;
data.MainData.ImmediateOrCancel = immediateOrCancel;
data.MainData.ExpirationDate = expirationDate;
account.api.Connection.OrderCreate(data);
// TODO: Zastanawiam się jeszczcze m.in. co z ClientId, TradeDate... i czy w ogóle byłby sens
// od razu tworzyć taki nowy obiekt BosOrder (zamiast zaczekać aż sam się doda przy OrderUpdate).
}
/// <summary>
/// Wysłanie do systemu nowego zlecenia z podanymi parametrami (pozostałe przyjmują
/// domyślną wartość null/false, a numer rachunku wyznaczany jest na podstawie typu instrumentu).
/// <para>Zobacz też metody klasy BosInstrument: Order, Buy, Sell - które od razu określają,
/// którego instrumentu dane zlecenie ma dotyczyć i ewentualnie prezyzują też stronę transakcji (kupno/sprzedaż)</para>
/// </summary>
/// <param name="instrument">Instrument, którego walory chcemy kupić/sprzedać.</param>
/// <param name="side">Zlecenie kupna (BosOrderSide.Buy) czy sprzedaży (BosOrderSide.Sell).</param>
/// <param name="price">Limit ceny, jaki wstawiamy do zlecenia (BosPrice.PKC/PCR/PCRO... lub po prostu kwota).</param>
/// <param name="quantity">Liczba walorów, jaką zamierzamy kupić/sprzedać.</param>
public static void Create(BosInstrument instrument, BosOrderSide side, BosPrice price, uint quantity)
{
Create(instrument, side, price, null, quantity, null, null, false, null);
}
// dołącza dane z innego obiektu tego samego typu, wywoływane z klasy BosInstruments
internal void Combine(BosInstrument source)
{
ISIN = ISIN ?? source.ISIN;
Symbol = Symbol ?? source.Symbol;
Sym = GetInstrumentSym();
Type = GetInstrumentType();
BuyOffers.Combine(source.BuyOffers);
SellOffers.Combine(source.SellOffers);
Trades.Combine(source.Trades);
Session.Combine(source.Session);
}
