// 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); }