From 660c5d3a063bbc2f8af4419828c26c39f1f04245 Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Thu, 24 May 2018 16:22:19 -0400 Subject: [PATCH 01/68] behold, TickOrder --- .../Orders/OrderModificationControl.xaml.cs | 6 + .../Orders/OrderTypeVMs/OrderTypeVMFactory.cs | 6 + .../spark/Orders/OrderTypeVMs/TickOrderVM.cs | 201 +++++++++++ .../Order/OrderDetailsPopupControl.xaml | 49 ++- .../spark/view/Spark/Ladder/LadderGridHost.cs | 4 +- .../view/Spark/Utilities/OrderDataHelper.cs | 17 +- src/lib/api/services/OrderService.proto | 15 +- .../orderman/order_factory/OrderFactory.cpp | 10 + .../sparkd/orderman/orders/NativeOrder.cpp | 13 + .../orderman/orders/book_algos/BookAlgo.cpp | 330 ++++++++++++++++++ .../orderman/orders/book_algos/BookAlgo.h | 59 ++++ .../orderman/orders/book_algos/TickOrder.cpp | 208 +++++++++++ .../orderman/orders/book_algos/TickOrder.h | 32 ++ 13 files changed, 943 insertions(+), 7 deletions(-) create mode 100644 src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs create mode 100644 src/server/sparkd/orderman/orders/book_algos/BookAlgo.cpp create mode 100644 src/server/sparkd/orderman/orders/book_algos/BookAlgo.h create mode 100644 src/server/sparkd/orderman/orders/book_algos/TickOrder.cpp create mode 100644 src/server/sparkd/orderman/orders/book_algos/TickOrder.h diff --git a/src/client/spark/Orders/OrderModificationControl.xaml.cs b/src/client/spark/Orders/OrderModificationControl.xaml.cs index 0e6f61c46..85ea5f022 100644 --- a/src/client/spark/Orders/OrderModificationControl.xaml.cs +++ b/src/client/spark/Orders/OrderModificationControl.xaml.cs @@ -20,6 +20,9 @@ namespace mbts.ui.spark { public DataTemplate StopLimitOrderTemplate { get; set; } public DataTemplate StopMarketOrderTemplate { get; set; } public DataTemplate TimeBoxOrderTemplate { get; set; } + public DataTemplate TickOrderTemplate { get; set; } + public DataTemplate JoinOrderTemplate { get; set; } + public DataTemplate LeaderOrderTemplate { get; set; } public DataTemplate IcebergOrderTemplate { get; set; } public DataTemplate SpreaderTemplate { get; set; } public DataTemplate BTSStopOrderTemplate { get; set; } @@ -33,6 +36,9 @@ namespace mbts.ui.spark { case CustomOrderDefinition.CustomOneofCase.Stop: return StopMarketOrderTemplate; case CustomOrderDefinition.CustomOneofCase.StopLimit: return StopLimitOrderTemplate; case CustomOrderDefinition.CustomOneofCase.TimeBox: return TimeBoxOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Tick: return TickOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Join: return JoinOrderTemplate; + case CustomOrderDefinition.CustomOneofCase.Leader: return LeaderOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Iceberg: return IcebergOrderTemplate; case CustomOrderDefinition.CustomOneofCase.Spreader: return SpreaderTemplate; } diff --git a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs index 3e780a072..0b4892556 100644 --- a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs +++ b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs @@ -14,6 +14,9 @@ namespace mbts.spark { public static IOrderTypeVM stop(OrdersModel model) => new StopOrderVM(model); public static IOrderTypeVM stop_limit(OrdersModel model) => new StopLimitOrderVM(model); public static IOrderTypeVM time_box(OrdersModel model, IObservable security_source) => new TimeBoxOrderVM(model, security_source); + public static IOrderTypeVM tick(OrdersModel model, IObservable security_source) => new TickOrderVM(model, security_source); + public static IOrderTypeVM join(OrdersModel model, IObservable security_source) => new TickOrderVM(model, security_source); + public static IOrderTypeVM leader(OrdersModel model, IObservable security_source) => new TickOrderVM(model, security_source); public static IOrderTypeVM iceberg(OrdersModel model, IObservable security_source) => new IcebergOrderVM(model, security_source); public static IOrderTypeVM spreader(OrdersModel model, IObservable security_source) => new SpreaderOrderVM(model, security_source); @@ -27,6 +30,9 @@ namespace mbts.spark { case CustomOneofCase.Stop: return stop(model); case CustomOneofCase.StopLimit: return stop_limit(model); case CustomOneofCase.TimeBox: return time_box(model, security_source); + case CustomOneofCase.Tick: return tick(model, security_source); + case CustomOneofCase.Join: return join(model, security_source); + case CustomOneofCase.Leader: return leader(model, security_source); case CustomOneofCase.Iceberg: return iceberg(model, security_source); case CustomOneofCase.Spreader: return spreader(model, security_source); default: throw new NotImplementedException(); diff --git a/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs new file mode 100644 index 000000000..6bd478faf --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs @@ -0,0 +1,201 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui; +using mbts.ui.utility; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.ComponentModel; +using System.Linq; +using System.Reactive.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark +{ + static partial class OrderTypeVMFactory + { + class InlineTickOrderProperties + { + public InlineTickOrderProperties (CustomOneofCase selected_child_order_type, IReadOnlyCollection child_order_types) + { + ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); + this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); + this.child_order_types = new InlineUserProperty>(child_order_types, true); + min_ticks_off_on_deploy = new InlineUserProperty(0, false); + cross_threshold = new InlineUserProperty( + new bts.spark.QuantityMeasure() { Absolute = 1}, false); + cross_ticks = new InlineUserProperty(0, false); + max_chase_ticks = new InlineUserProperty(10, false); + pay_up_on_toward = new InlineUserProperty(true, false); + } + public readonly InlineUserProperty selected_child_order_type; + public readonly InlineUserProperty> child_order_types; + + public readonly InlineUserProperty min_ticks_off_on_deploy; + public readonly InlineUserProperty cross_threshold; + public readonly InlineUserProperty cross_ticks; + public readonly InlineUserProperty max_chase_ticks; + public readonly InlineUserProperty pay_up_on_toward; + } + + class TickOrderVM : OrderTypeVMBase, IHierarchicalOrderTypeVM, IDisposable + { + readonly IObservable _security_source; + SecurityImmutable? _security; + ObservableCollection _order_types = new ObservableCollection(); + ObservableAutoWrapper _child_order_choices; + InlineTickOrderProperties _inline_props; + IOrderTypeVM _child_order; + IDisposable _dispose, _child_order_errors_sub; + + public uint min_ticks_off_on_deploy { get; set; } = 0; + public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Absolute = 1 }; + public uint cross_ticks { get; set; } = 0; + public uint max_chase_ticks { get; set; } = 10; + public bool pay_up_on_toward { get; set; } = true; + + public TickOrderVM(OrdersModel model, IObservable security_source) + : this(model, security_source, security_source.Select(s => + new InlineTickOrderProperties(model.factory.default_order_type(s), model.factory.default_order_types(s).ToList()))) { } + + public TickOrderVM(OrdersModel model, IObservable security_source, + IObservable inline_properties) : base(model) + { + _security_source = security_source; + _dispose = Disposable.Create( + security_source.ObserveOnDispatcher() + .Subscribe(s => _security = s), + inline_properties.ObserveOnDispatcher() + .Subscribe(p => { + if (_order_types.Count == 0 || p.child_order_types.force_override) + { + _order_types.SetItems(p.child_order_types.value); + } + if (_child_order_choices != null && (_child_order == null || p.selected_child_order_type.force_override)) + { + _select_child_order(p.selected_child_order_type.value); + } + if (p.min_ticks_off_on_deploy.force_override) + { + min_ticks_off_on_deploy = p.min_ticks_off_on_deploy.value; + RaisePropertyChanged(nameof(min_ticks_off_on_deploy)); + } + if (p.cross_threshold.force_override) + { + cross_threshold = p.cross_threshold.value; + RaisePropertyChanged(nameof(cross_threshold)); + } + if (p.cross_ticks.force_override) + { + cross_ticks = p.cross_ticks.value; + RaisePropertyChanged(nameof(cross_ticks)); + } + if (p.max_chase_ticks.force_override) + { + max_chase_ticks = p.max_chase_ticks.value; + RaisePropertyChanged(nameof(max_chase_ticks)); + } + if (p.pay_up_on_toward.force_override) + { + pay_up_on_toward = p.pay_up_on_toward.value; + RaisePropertyChanged(nameof(pay_up_on_toward)); + } + _inline_props = p; + _validate(); + }) + ); + _validate(); + } + + public override void assign_to(CustomOrderDefinition value) + { + if (_child_order == null) + _select_child_order(model.factory.default_order_type(_security.Value, true)); + _validate(); + if (!HasErrors) + { + var i = factory.tick_order(); + i.MinTicksOffOnDeploy = min_ticks_off_on_deploy; + i.CrossThreshold = cross_threshold; + i.CrossTicks = cross_ticks; + i.MaxChaseTicks = max_chase_ticks; + i.PayUpOnToward = pay_up_on_toward; + child_order.assign_to(i.Child); + value.Tick = i; + } + } + + public ICollection child_order_types + { + get + { + if (_child_order_choices == null) + _child_order_choices = new ObservableAutoWrapper(_order_types, ot => create(ot, model, _security_source)); + return _child_order_choices; + } + } + + public IOrderTypeVM child_order + { + get + { + init(); + return _child_order; + } + set + { + Disposable.dispose(ref _child_order_errors_sub); + _child_order = value; + _child_order?.init(); + if (_child_order is INotifyDataErrorInfo ndei) + { + ndei.ErrorsChanged += on_errors_changed; + void on_errors_changed(object s, DataErrorsChangedEventArgs e) => + _validate(); + _child_order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= on_errors_changed); + } + _validate(); + RaisePropertyChanged(nameof(child_order)); + } + } + + public void Dispose() + { + Disposable.dispose(ref _dispose); + if (_child_order_choices != null) + _child_order_choices.OfType().DisposeAll(); + } + + public override void init() + { + if (_child_order == null && _security.HasValue) + _select_child_order(); + _validate(); + } + + void _select_child_order() + { + CustomOneofCase ot = _inline_props != null && _inline_props.selected_child_order_type.has_value ? + _inline_props.selected_child_order_type.value : + model.factory.default_order_type(_security.Value, true); + _select_child_order(ot); + } + + void _select_child_order(CustomOneofCase ot) + { + _child_order = child_order_types.FirstOrDefault(vm => vm.order_type == ot); + if (_child_order == null) + _child_order = child_order_types.FirstOrDefault(); + RaisePropertyChanged(nameof(child_order)); + } + + void _validate() + { + if (_child_order == null || (_child_order is INotifyDataErrorInfo ndei && ndei.HasErrors)) + set_error(nameof(child_order), string.Empty, true); + else clear_error(nameof(child_order)); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml index 1d42ae646..1fcb942b0 100644 --- a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml +++ b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml @@ -10,6 +10,7 @@ + - + - + @@ -321,7 +321,9 @@ - + + + /// Interaction logic for ExecutionStrategyEditor.xaml /// - partial class ExecutionStrategyEditor : Control { + partial class ExecutionStrategyEditor : Control { + public const string + RemovableColumnHeaderTemplateKey = "RemovableColumnHeaderTemplate", + NonRemovableColumnHeaderTemplateKey = "ReadOnlyColumnHeaderTemplate", + AddColumnPlaceholderKey = "AddColumnPlaceholder"; static ExecutionStrategyEditor() => DefaultStyleKeyProperty.OverrideMetadata(typeof(ExecutionStrategyEditor), new FrameworkPropertyMetadata(typeof(ExecutionStrategyEditor))); @@ -196,7 +200,7 @@ namespace mbts.ui.spark { if (dg != null) { var legs = LegTuples; dg.Columns.SetItems(legs.Select(_column_factory)); - if (IsNew) dg.Columns.Add((DataGridColumn)FindResource("AddColumnPlaceholder")); + if (IsNew) dg.Columns.Add((DataGridColumn)FindResource(AddColumnPlaceholderKey)); _dg_line_adorner = AdornerHelper.attach_continuously_on_loaded(() => new ExecutionStrategyGridLineAdorner(dg), dg); _legs_collection_changed_sub = (legs as INotifyCollectionChanged)?.Subscribe((s, e) => dg.Columns.ReflectChange(legs, _column_factory, e)); } @@ -204,7 +208,7 @@ namespace mbts.ui.spark { DataGridColumn _column_factory(LegSpreaderParamsTuple l) { var col = new DataGridColumnInternal(l.leg.Security, ParameterCellTemplateConverter, ParameterCellEditingTemplateConverter) { Width = 75, }; - if (IsNew) col.HeaderTemplate = (DataTemplate)FindResource("RemovableColumnHeaderTemplate"); + col.HeaderTemplate = (DataTemplate)FindResource(IsNew ? RemovableColumnHeaderTemplateKey : NonRemovableColumnHeaderTemplateKey); DataGridEx.SetRightBorder(col, new DataGridExVerticalLine(false, true, Colors.DarkGray, 1)); return col; } @@ -240,7 +244,7 @@ namespace mbts.ui.spark { FrameworkElement _generate_element(IValueConverter cell_template_converter) { var rv = new ContentControl(); rv.SetBinding(ContentControl.ContentProperty, new Binding()); - rv.SetBinding(ContentControl.ContentTemplateProperty, new Binding("data_type") { Converter = cell_template_converter }); + rv.SetBinding(ContentControl.ContentTemplateProperty, new Binding(nameof(ICell.data_type)) { Converter = cell_template_converter }); return rv; } } From 3a72a4a82eb4bbf24bdd7e40ff7a9c8bf72debb9 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Wed, 6 Jun 2018 10:11:23 -0400 Subject: [PATCH 42/68] Spreader's bookkeepingdata_ptr is a unique_ptr and some stylistic changes to shorten line widths --- .../orders/spreader_orders/SpreaderOrder.cpp | 2 +- .../orders/spreader_orders/SpreaderOrder.h | 2 +- .../spreader/SingleFillHedger.h | 14 +++-- .../spreader/SingleLegQuoter.h | 26 ++++---- .../SpreaderEndStateWorker.cpp | 2 +- .../spreader_states/SpreaderEndStateWorker.h | 21 ++++--- .../SpreaderStartStateWorker.cpp | 6 +- .../SpreaderWorkingStateWorker.cpp | 63 +++++++------------ .../SpreaderWorkingStateWorker.h | 21 ++++--- 9 files changed, 74 insertions(+), 83 deletions(-) diff --git a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp index fd6ddb70e..ef396e46c 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp @@ -15,7 +15,7 @@ SpreaderOrder::SpreaderOrder() _cancelled (false), _cancel_timeout (5000),// TODO:get it from config _active(true), - _bookkeeping_data_ptr(nullptr), + //_bookkeeping_data_ptr(nullptr), _order_services(nullptr), _reported_state(), _state_worker(nullptr), diff --git a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h index c74e19e23..d30a40088 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h @@ -52,7 +52,7 @@ private: // is false if created from disk const bool _active; // this is the main data - SpreaderBookkeepingData* _bookkeeping_data_ptr; + std::unique_ptr _bookkeeping_data_ptr; // pointer kept to send reports SpreaderOrderServices* _order_services; // state thats sent out in report (its kept here vs creating a new one everytime) diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleFillHedger.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleFillHedger.h index 30417ac9d..d9923eb30 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleFillHedger.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleFillHedger.h @@ -73,21 +73,23 @@ public: SingleFillHedger (SingleFillHedger&&); SingleFillHedger& operator=(const SingleFillHedger&) = delete; SingleFillHedger& operator=(SingleFillHedger&&) = delete; - //1. leave the start state and submit the order + // the a-f actions are associated with the state machine + // side effect actions + //a. leave the start state and submit the order void init(); - //2. called by the spreader when there is an order update + //b. called by the spreader when there is an order update // reported by the exchange void on_order_update(const SpreaderChildOrderState& order_update_message); - //3. called when the market data associated + //c. called when the market data associated // with this security is changed void on_book(bts::orderman::TickToTradeCorID corid, const bts::orderman::Book& book); - //4. called when the hedge order is cancelled, either + //d. called when the hedge order is cancelled, either // manually or automatically void cancel_hedge(); - //5. immediatly terminates this hedger, without any attempts + //e. immediatly terminates this hedger, without any attempts // to cancel the order void terminate (); - //6. on the engine infrastructure time + //f. on the engine infrastructure time void on_time(const bts::TimeStamp&); // returns true if the quoter is in the final state, from which // it will never come back diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleLegQuoter.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleLegQuoter.h index a3c0ee6aa..31615a63c 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleLegQuoter.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader/SingleLegQuoter.h @@ -65,36 +65,38 @@ public: SpreaderChildOrderState& child_order_state); public: SingleLegQuoter() = delete; - SingleLegQuoter (SingleLegQuoter&&); - SingleLegQuoter (const SingleLegQuoter&) = delete; + SingleLegQuoter(SingleLegQuoter&&); // implementation has an assert since it will not be called + SingleLegQuoter(const SingleLegQuoter&) = delete; SingleLegQuoter& operator=(const SingleLegQuoter&) = delete; SingleLegQuoter& operator=(SingleLegQuoter&&) = delete; public: - //1. this is called only once. this all could have been passed in + // the a-h actions are associated with the state machine + // side effect actions + //a. this is called only once. this could have been passed in // the constructor, but the spreader is created in 2 stages. // all the memory is allocated in a slow path and then values // are initialized on fast activation path void one_time_activate (Price, Quantity); - //2. called by the spreader a change in + //b. called by the spreader a change in // order status(or fills) is reported // by the exchange // by the exchange void update_order_status(const SpreaderChildOrderState& u); - //3. called when the market data associated + //c. called when the market data associated // with this security is changed void on_book(bts::orderman::TickToTradeCorID cid, size_t leg_index, const bts::orderman::Book&); - //4. called when the order is cancelled, either + //d. called when the order is cancelled, either // manually or automatically void cancel_order(); - //5. the quoter forgets everything and goes to the end state + //e. the quoter forgets everything and goes to the end state void terminate (); - //6. time update + //f. time update void on_time(const bts::TimeStamp&); - //7. this is called by the spreader when a quoting fill + //g. this is called by the spreader when a quoting fill // (ie not hedging fill) happens on one of the quoting // legs void update_other_leg_fills(size_t leg_index, Quantity filled_quantity); - //8. called when the user modified the spreader order price or quantity + //h. called when the user modified the spreader order price or quantity void update_order_price_quantity(Price price, Quantity quantity); // true if the quoter has an active working order. the order can // be in an unknown state, but as long as an order has been sent @@ -125,8 +127,8 @@ public: private: bts::orderman::OrderKey _key() {return _child_order_state.order_key();} TimeStamp _current_time () const {return _spreader.current_time();} - std::string _log_prefix() - { + // TODO: state out and move the string to a const + std::string _log_prefix(){ std::ostringstream oss; oss << " spreader_order_key: " << _spreader.spreader_order_key(); oss << " sec_key: " << _this_leg_data.security_key(); diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp index e1aa7b904..48b657f02 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp @@ -24,7 +24,7 @@ void SpreaderEndStateWorker::on_init_recovered(const bts::api::orderman::OrderRe void SpreaderEndStateWorker::on_activate(Price price, Quantity quantity, SpreaderOrderServices&){ // this can only happen if the security could not be resolved - // resulting in START->END. however on_active will could still + // resulting in START->END. however on_active could still // be called bts_assert (!_spreader->_bookkeeping_data().all_legs_resolved()); _spreader->_bookkeeping_data().update_order(price, quantity); diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.h index 20efa86a9..e2413311f 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.h @@ -6,26 +6,27 @@ namespace orderman { class SpreaderOrder; -class SpreaderEndStateWorker : public ISpreaderStateWorker -{ +class SpreaderEndStateWorker : public ISpreaderStateWorker{ private: SpreaderOrder* const _spreader; public: SpreaderEndStateWorker (SpreaderOrder*); - void on_transition() override; SpreaderState state() const override; - void on_init_new(api::orderman::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override; - void on_init_recovered(const bts::api::orderman::OrderRecord&, const SpreaderPreActivationOrderServices&) override; + void on_transition() override; + void on_init_new(const api::orderman::OrderDefinition&, + const SpreaderPreActivationOrderServices&) override; + void on_init_recovered(const bts::api::orderman::OrderRecord&, + const SpreaderPreActivationOrderServices&) override; void on_activate(Price, Quantity, SpreaderOrderServices&) override; void on_update(Price, Quantity) override; void on_cancel() override; - void on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) override; + void on_book(TickToTradeCorID, const Book&) override; void on_time(const TimeStamp&) override; - void on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data) override; - void on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data) override; - void on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data) override; + void on_quoter_order_error(SpreaderLegData& leg_data) override; + void on_quoter_order_fill(SpreaderLegData& leg_data) override; + void on_quoter_order_status_update(SpreaderLegData& leg_data) override; void on_hedger_order_error(SingleFillHedger&) override; void on_hedger_order_update(SingleFillHedger&) override; - void on_check_termination () override; + void on_check_termination() override; }; }} diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp index f8fbb7ee5..e67ad9729 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp @@ -22,10 +22,10 @@ void SpreaderStartStateWorker::on_init_new(const api::orderman::OrderDefinition& bts_assert(!_spreader->_inited()); std::vector spreader_legs; if (SpreaderUtils::resolve_synthetic_spread (spreader_pao_services, order_def, spreader_legs, false)) - _spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, _spreader->key(), order_def, spreader_pao_services, spreader_legs); + _spreader->_bookkeeping_data_ptr = std::make_unique(*_spreader, _spreader->key(), order_def, spreader_pao_services, spreader_legs); else { - _spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, _spreader->key(), order_def, spreader_pao_services, std::vector()); + _spreader->_bookkeeping_data_ptr = std::make_unique(*_spreader, _spreader->key(), order_def, spreader_pao_services, std::vector()); // if securities can not be resolved, the order is terminated LOG(OrderMan, Error, "SpreaderStartStateWorker.on_init_new key: {} , could not resolve securities", _spreader->key().value()); std::string msg = "Could not resolve securities"; @@ -36,7 +36,7 @@ void SpreaderStartStateWorker::on_init_recovered(const bts::api::orderman::Order { bts_assert(!_spreader->_inited()); // we are not handling this yet, so lets send it directly to END - _spreader->_bookkeeping_data_ptr = new SpreaderBookkeepingData (*_spreader, _spreader->key(), order_record.def(), spreader_pao_services, std::vector()); + _spreader->_bookkeeping_data_ptr = std::make_unique(*_spreader, _spreader->key(), order_record.def(), spreader_pao_services, std::vector()); LOG(OrderMan, Warn, "SpreaderStartStateWorker.on_init_recovered key: {} , going to END", _spreader->key().value()); std::string msg = "Recovered spreader orders and not supported"; _spreader->_transform_to_END (&msg); diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp index 4fe8b5bf6..f1ba07a8d 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp @@ -9,50 +9,47 @@ SpreaderWorkingStateWorker::SpreaderWorkingStateWorker (SpreaderOrder* spreader) : _spreader(spreader) {} -SpreaderState SpreaderWorkingStateWorker::state() const {return SpreaderState::WORKING;} -void SpreaderWorkingStateWorker::on_transition() -{} -void SpreaderWorkingStateWorker::on_init_new(api::orderman::OrderDefinition const&, const SpreaderPreActivationOrderServices&) -{ +SpreaderState SpreaderWorkingStateWorker::state() const { + return SpreaderState::WORKING; +} +void SpreaderWorkingStateWorker::on_transition(){ +} +void SpreaderWorkingStateWorker::on_init_new(api::orderman::OrderDefinition const&, + const SpreaderPreActivationOrderServices&){ bts_assert_msg (false, "SpreaderWorkingStateWorker::on_init_new is an illegal operation"); } -void SpreaderWorkingStateWorker::on_init_recovered(const bts::api::orderman::OrderRecord&, const SpreaderPreActivationOrderServices&) -{ +void SpreaderWorkingStateWorker::on_init_recovered(const bts::api::orderman::OrderRecord&, + const SpreaderPreActivationOrderServices&){ bts_assert_msg (false, "SpreaderWorkingStateWorker::on_init_recovered is an illegal operation"); } -void SpreaderWorkingStateWorker::on_activate(Price, Quantity, SpreaderOrderServices&) -{ +void SpreaderWorkingStateWorker::on_activate(Price, Quantity, + SpreaderOrderServices&){ bts_assert_msg (false, "SpreaderWorkingStateWorker::on_activate is an illegal operation"); } -void SpreaderWorkingStateWorker::on_update(Price price, Quantity quantity) -{ - if (_spreader->_quoters_can_accept_modification()) - { +void SpreaderWorkingStateWorker::on_update(Price price, Quantity quantity){ + if (_spreader->_quoters_can_accept_modification()){ _spreader->_set_price_quantity (price, quantity); // updating all active quoters, nothing to do with the hedgers - for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++) - { + for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) leg_data.quoter().update_order_price_quantity (price, quantity); } } } -void SpreaderWorkingStateWorker::on_cancel() -{ +void SpreaderWorkingStateWorker::on_cancel(){ _spreader->_cancel_orders (true, true); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } -void SpreaderWorkingStateWorker::on_book(bts::orderman::TickToTradeCorID cid, const bts::orderman::Book& book) -{ +void SpreaderWorkingStateWorker::on_book(TickToTradeCorID cid, + const Book& book){ SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data(); // this is a key->index lookup SpreaderLegData& md_leg = bookkeeping_data.get_leg_data(book.security_key()); // updating md state (this is the only place where its done) md_leg.update_book(book); // sending md to all quoters - for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++) - { + for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++){ SpreaderLegData& d = bookkeeping_data.get_leg_data(q_idx); if (d.leg_property_data().is_active_quoting()) d.quoter().on_book(cid, md_leg.leg_property_data().leg_index(), book); @@ -61,11 +58,9 @@ void SpreaderWorkingStateWorker::on_book(bts::orderman::TickToTradeCorID cid, co for (size_t h_idx = 0; h_idx < md_leg.n_hedgers(); h_idx++) md_leg.get_hedger(h_idx).on_book(cid, book); } -void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts) -{ +void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts){ SpreaderBookkeepingData& bookkeeping_data = _spreader->_bookkeeping_data(); - for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++) - { + for (size_t q_idx = 0; q_idx < bookkeeping_data.n_legs(); q_idx++){ SpreaderLegData& leg_data = bookkeeping_data.get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) leg_data.quoter().on_time(ts); @@ -73,15 +68,13 @@ void SpreaderWorkingStateWorker::on_time(const TimeStamp& ts) leg_data.get_hedger(h_idx).on_time (ts); } } -void SpreaderWorkingStateWorker::on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data) -{ +void SpreaderWorkingStateWorker::on_quoter_order_error(SpreaderLegData& leg_data){ // this is because the error message could also have status changes leg_data.quoter().update_order_status (leg_data.order_update_message()); _spreader->_cancel_orders (true, true); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } -void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data) -{ +void SpreaderWorkingStateWorker::on_quoter_order_fill(SpreaderLegData& leg_data){ // this is the most complex part of the spreader. the following needs to be done // 1. tell other quoters about it (so they reduce their sizes) // 2. launch a new hedger @@ -101,11 +94,9 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(bts::orderman::SpreaderLeg LOG(OrderMan, Info, "SpreaderWorkingStateWorker::on_quoter_order_fill order: key: {} order_key: {} status: {} filled_qty: {} last_price: {}", _spreader->key(), order_update_message.order_key(), order_update_message.status(), order_update_message.last_update_filled_quantity(), order_update_message.last_update_filled_price()); bts_assert (order_update_message.last_update_filled_quantity().value() > 0); - for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++) - { + for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& other_leg_data = _spreader->_bookkeeping_data().get_leg_data (q_idx); - if (q_idx != leg_data.leg_property_data().leg_index()) - { + if (q_idx != leg_data.leg_property_data().leg_index()){ // if it is an actively quoting leg, inform the quoter about it // so it can decrease the proportional size if (other_leg_data.leg_property_data().is_active_quoting()) @@ -140,10 +131,4 @@ void SpreaderWorkingStateWorker::on_check_termination() if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state()) _spreader->_transform_to_END (); } -bool SpreaderWorkingStateWorker::_is_leg_filled (size_t leg_idx) const -{ - const SpreaderLegData& leg_data = _spreader->_bookkeeping_data().get_leg_data(leg_idx); - Quantity leg_target_qty = SpreaderUtils::get_leg_quantity_from_spreader_quantity (leg_data.leg_property_data(), _spreader->_bookkeeping_data().quantity()); - return leg_data.total_fills().value() >= leg_target_qty.value(); -} }} diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h index e5340ce4d..010ad6ead 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.h @@ -14,21 +14,22 @@ public: SpreaderWorkingStateWorker (SpreaderOrder*); void on_transition() override; SpreaderState state() const override; - void on_init_new(api::orderman::OrderDefinition const&, const SpreaderPreActivationOrderServices&) override; - void on_init_recovered(const bts::api::orderman::OrderRecord&, const SpreaderPreActivationOrderServices&) override; - void on_activate(Price, Quantity, SpreaderOrderServices&) override; + void on_init_new(api::orderman::OrderDefinition const&, + const SpreaderPreActivationOrderServices&) override; + void on_init_recovered(const bts::api::orderman::OrderRecord&, + const SpreaderPreActivationOrderServices&) override; + void on_activate(Price, Quantity, + SpreaderOrderServices&) override; void on_update(Price, Quantity) override; void on_cancel() override; - void on_book(bts::orderman::TickToTradeCorID, const bts::orderman::Book&) override; + void on_book(TickToTradeCorID, + const Book&) override; void on_time(const TimeStamp&) override; - void on_quoter_order_error(bts::orderman::SpreaderLegData& leg_data) override; - void on_quoter_order_fill(bts::orderman::SpreaderLegData& leg_data) override; - void on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data) override; + void on_quoter_order_error(SpreaderLegData& leg_data) override; + void on_quoter_order_fill(SpreaderLegData& leg_data) override; + void on_quoter_order_status_update(SpreaderLegData& leg_data) override; void on_hedger_order_error(SingleFillHedger&) override; void on_hedger_order_update(SingleFillHedger&) override; void on_check_termination () override; -private: - bool _is_leg_filled (size_t leg_idx) const; }; - }} From ccea4571a6cb2daf280e9ee1a76be8e9ba8bbad3 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Wed, 6 Jun 2018 10:24:19 -0400 Subject: [PATCH 43/68] SPARK-1206 uninitialized limit returned --- src/server/sparkd/orderman/limiter/SecurityLimitNode.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/server/sparkd/orderman/limiter/SecurityLimitNode.h b/src/server/sparkd/orderman/limiter/SecurityLimitNode.h index 37025c849..dbc533094 100644 --- a/src/server/sparkd/orderman/limiter/SecurityLimitNode.h +++ b/src/server/sparkd/orderman/limiter/SecurityLimitNode.h @@ -64,7 +64,7 @@ public: // risk limit checks //////////////////// Limiter::LimiterQueryResult can_send_new_order(api::Side side, Quantity quantity) const{ - Limiter::LimiterQueryResult result; + Limiter::LimiterQueryResult result;result.ok=true; if (quantity.value() > _clip_size){ result.ok = false; result.error_msg = fmt::format("Security Clip Size (Max {} Qty {})", _clip_size, quantity.value()); From a2f22482f6b6ef685e8b1de836b4ddb5b91f7db3 Mon Sep 17 00:00:00 2001 From: Jake Norbut Date: Wed, 6 Jun 2018 09:36:21 -0500 Subject: [PATCH 44/68] removing perf testing code; removing unused orders_cache --- src/client/spark/view/Spark/Ladder/LadderVM.cs | 18 +++++------------- 1 file changed, 5 insertions(+), 13 deletions(-) diff --git a/src/client/spark/view/Spark/Ladder/LadderVM.cs b/src/client/spark/view/Spark/Ladder/LadderVM.cs index a204851c7..ec89d8b32 100644 --- a/src/client/spark/view/Spark/Ladder/LadderVM.cs +++ b/src/client/spark/view/Spark/Ladder/LadderVM.cs @@ -70,16 +70,9 @@ namespace mbts.spark { order_properties_vm = new OrderPropertiesEditorVM(model.order_gateway, Observable.Return(security), _settings_manager.subscribe_current().Select(s => new InlineOrderProperties(model.order_gateway, s))), size_calculator = new CalculatorLogic(0, _settings_manager.subscribe_current().Select(s => s.calculator_buttons)), bus.subscribe(SparkTags.LogActivity).ObserveOnDispatcher().Subscribe(status_update), - // need to subscribe to all orders, and cache them, because parent orders don't necessarily have the same security - // and OrderVM needs access to parent orders, if there are any - model.order_gateway.working_orders.ObserveOnDispatcher().Subscribe(working => { // Here we manage N orders to 1 price slot in the ladder - // there is likely a smarter way to do this than creating this anew each time - // need to do something about stop and stop limits in here - int add_count = 0; - int new_count = 0; - var updated_slot_prices_vs_orders = new Dictionary(); + HashSet prices_used_in_this_update = new HashSet(); Dictionary> orders_used_in_this_update = new Dictionary>(); var ladders_orders = working.Values.Where(o => o.Def.SecurityKey == security.Id); @@ -100,12 +93,13 @@ namespace mbts.spark { _slot_price_vs_orders.TryGetValue(slot_price_target, out LadderOrderVM slot_vm); if (slot_vm != null) { slot_vm.add_order(wo); - add_count++; } else { slot_vm = new LadderOrderVM(wo, slot_price_target, this, _bus, _settings_manager.subscribe_current().Select(s => s.badge_style)); _slot_price_vs_orders[slot_price_target] = slot_vm; - new_count++; } + + // keep track of slot prices vs orders; we use this below to remove orders from the LadderOrderVMs + // that are not found in this callback run orders_used_in_this_update.TryGetValue(slot_price_target, out HashSet orders_at_level); if (orders_at_level == null) { orders_at_level = new HashSet(); @@ -141,9 +135,8 @@ namespace mbts.spark { _slot_price_vs_orders.Remove(slot_price); } } - System.Diagnostics.Debug.WriteLine($"New Count {new_count} Add Count {add_count}"); + orders.sync_with(_slot_price_vs_orders.Values); - orders_cache = working; }), WorkLoop.Start($"Ladder '{security}'", _tick) ); @@ -194,7 +187,6 @@ namespace mbts.spark { public Brush ask_foreground => _ask_foreground.Value; public DialogCommand settings_command { get; } internal LadderModel model => _model; - internal IReadOnlyDictionary orders_cache { get; private set; } = new Dictionary(); internal IObservable settings => _settings_manager.subscribe_current(); public LadderSettings get_save_state() { From e1940faeacaad03583504204255e8e876bf240e4 Mon Sep 17 00:00:00 2001 From: Michael Harding Date: Tue, 5 Jun 2018 15:49:41 -0400 Subject: [PATCH 45/68] AdminUI: Add Modal Dialog --- src/web/ui/src/Controls/Fields.fs | 1 - src/web/ui/src/Controls/Modal.fs | 39 +++++++++++++++++++++++++++++++ src/web/ui/src/Global.fs | 1 + src/web/ui/src/ui.fsproj | 1 + 4 files changed, 41 insertions(+), 1 deletion(-) create mode 100644 src/web/ui/src/Controls/Modal.fs diff --git a/src/web/ui/src/Controls/Fields.fs b/src/web/ui/src/Controls/Fields.fs index 9feac6a6a..c047b8486 100644 --- a/src/web/ui/src/Controls/Fields.fs +++ b/src/web/ui/src/Controls/Fields.fs @@ -8,7 +8,6 @@ open Fable.Import.React open Global open Fable open JSMap -open Fable let text (lbl:string) (dv:string) (attrs:IHTMLProp list) onchange = div [ ClassName "field" ] diff --git a/src/web/ui/src/Controls/Modal.fs b/src/web/ui/src/Controls/Modal.fs new file mode 100644 index 000000000..3815eda29 --- /dev/null +++ b/src/web/ui/src/Controls/Modal.fs @@ -0,0 +1,39 @@ +module Modal + +open Fable.Core +open Fable.Core.JsInterop +open Fable.Helpers.React +open Fable.Helpers.React.Props +open Fable.Import.React +open Global +open Fable + + +let show (title:string) (content:ReactElement) (footerContent:ReactElement) (onCloseClick: MouseEvent -> Unit) = + div [ Class "modal is-active" ] + [ div [ Class "modal-background" ][ ] + div [ Class "modal-card" ] + [ header [ Class "modal-card-head" ] + [ p [ Class "modal-card-title" ][ str title ] + button [ Class "delete"; OnClick onCloseClick ] [ ] + ] + section [ Class "modal-card-body" ] [ content ] + footer [ Class "modal-card-foot" ] [ footerContent ] + ] + ] + +let showCreate title content (onCreateClick: MouseEvent -> Unit) (onCloseClick: MouseEvent -> Unit) = + show + title + content + (div [] [ button [ Class "button is-success"; OnClick onCreateClick ] + [ str "Create" ] + button [ Class "button"; OnClick onCloseClick ] + [ str "Cancel" ] + ]) + (onCloseClick: MouseEvent -> Unit) + + + + + \ No newline at end of file diff --git a/src/web/ui/src/Global.fs b/src/web/ui/src/Global.fs index 113ff0ca9..4b6dfe9df 100644 --- a/src/web/ui/src/Global.fs +++ b/src/web/ui/src/Global.fs @@ -1,6 +1,7 @@ module Global open Fable.Core +let Class = Fable.Helpers.React.Props.HTMLAttr.ClassName type AlertLevel = | Info diff --git a/src/web/ui/src/ui.fsproj b/src/web/ui/src/ui.fsproj index 6921e129e..e2317a935 100644 --- a/src/web/ui/src/ui.fsproj +++ b/src/web/ui/src/ui.fsproj @@ -40,6 +40,7 @@ + From 3107d5f38242927dcfcbd50ebaadb6b82bc720e6 Mon Sep 17 00:00:00 2001 From: Michael Harding Date: Wed, 6 Jun 2018 09:59:24 -0400 Subject: [PATCH 46/68] SPARK-1201: Add modal create dialog for Users and Accounts --- src/web/ui/src/Accounts/State.fs | 13 ++++++---- src/web/ui/src/Accounts/Types.fs | 1 + src/web/ui/src/Accounts/View.fs | 17 ++++++++++++ src/web/ui/src/Users/State.fs | 44 +++++++++++++++++++++----------- src/web/ui/src/Users/Types.fs | 1 + src/web/ui/src/Users/View.fs | 21 ++++++++++----- 6 files changed, 70 insertions(+), 27 deletions(-) diff --git a/src/web/ui/src/Accounts/State.fs b/src/web/ui/src/Accounts/State.fs index 4d5ae15ea..89e4c93f3 100644 --- a/src/web/ui/src/Accounts/State.fs +++ b/src/web/ui/src/Accounts/State.fs @@ -20,19 +20,22 @@ let init (context:ServiceContext.ServiceContext) = mdRelayProductData = [||] mdRelayExpNameData = Array.empty scratch = emptyAccount + previousScratch = emptyAccount AllValue = " " AllValueDisplay = "All" }, Access.getAdminData admin UpdateAdminData NoAdminData -let existingSelection (scratch:BTSAccount) (data:AdminData) = +let existingSelection (scratch:BTSAccount) (previousScratch:BTSAccount) (data:AdminData) = + printf "%O" data.accounts List.choose id [ data.accounts |> Array.tryFind (fun a -> a.name = scratch.name) + data.accounts |> Array.tryFind (fun a -> a.name = previousScratch.name) data.accounts |> Array.tryHead Some emptyAccount] |> List.head let preserveSelection (data:AdminData) model = - let account = existingSelection model.scratch data + let account = existingSelection model.scratch model.previousScratch data { model with scratch = account } @@ -98,7 +101,7 @@ let erase (arr:'a[]) i = let update msg (model:Model) : Model * Cmd = match msg with | UpdateAdminData data -> - let presentAccounts = data.accounts |> Array.filter (fun a -> a.isPresent) |> Array.sortBy (fun a -> a.name) + let presentAccounts = data.accounts |> Array.filter (fun a -> a.isPresent) |> Array.sortBy (fun a -> a.name.ToLower()) let data = { data with accounts = presentAccounts } { model with adminData = Some data } |> preserveSelection data, Cmd.ofExistingPromise (requestProducts model.mdRelay) id (box>>ErrorOccured) @@ -107,14 +110,14 @@ let update msg (model:Model) : Model * Cmd = model, Cmd.Empty | SelectAccount account -> // When an account is selected 'scratch' account is discarded - { model with scratch = account }, Cmd.Empty + { model with previousScratch = model.scratch; scratch = account }, Cmd.Empty | DeleteAccount account -> match Fable.Import.Browser.window.confirm (sprintf "Are you sure you want to delete '%s'" account.name) with | true -> model, Cmd.ofExistingPromise (deleteAccount model.admin account) id (box>>ErrorOccured) | false -> model, Cmd.Empty | AddAccount -> // Create a new scratch account. Send to server after user has filled in details - { model with scratch = emptyAccount }, Cmd.ofMsg <| SelectTab General + { model with previousScratch = model.scratch; scratch = emptyAccount }, Cmd.ofMsg <| SelectTab General | SaveScratch -> match isNewAccount model.scratch with | true -> model, Cmd.ofExistingPromise (createAccount model.admin model.scratch) id (box>>ErrorOccured) diff --git a/src/web/ui/src/Accounts/Types.fs b/src/web/ui/src/Accounts/Types.fs index 3fcec4787..d9817eda2 100644 --- a/src/web/ui/src/Accounts/Types.fs +++ b/src/web/ui/src/Accounts/Types.fs @@ -28,6 +28,7 @@ type Model = { mdRelayProductData: Product[] mdRelayExpNameData: ExpirationNameList[] scratch : BTSAccount + previousScratch : BTSAccount AllValue: string AllValueDisplay: string } diff --git a/src/web/ui/src/Accounts/View.fs b/src/web/ui/src/Accounts/View.fs index 14949fe16..169da4c46 100644 --- a/src/web/ui/src/Accounts/View.fs +++ b/src/web/ui/src/Accounts/View.fs @@ -61,12 +61,29 @@ let mappedDataGridWithAddDelete<'a,'r> title (descriptor:MappedDataGridDescripto // let generalView model dispatch = let account = model.scratch + + let revertFun = + match model.adminData with + | Some data -> fun _ -> (dispatch <| SelectAccount (State.existingSelection model.scratch model.previousScratch data)) + | None -> fun _ -> (dispatch <| SelectAccount emptyAccount) + + let modal = Modal.showCreate + "Create Account" + (div [] [ + Fields.text "Name" account.name [] (AccountName >> Update >> dispatch) + Fields.text "Description" account.description [] (Description >> Update >> dispatch) + Fields.checkbox "Active" "" account.isActive [] (IsActive >> Update >> dispatch) + ]) + (fun _ -> dispatch SaveScratch) + revertFun + div [] [ p [ Style [FontWeight "Bold"] ] [ str ("ID: " + (string account.id))] br [] Fields.text "Name" account.name [] (AccountName >> Update >> dispatch) Fields.text "Description" account.description [] (Description >> Update >> dispatch) Fields.checkbox "Active" "" account.isActive [] (IsActive >> Update >> dispatch) + (if State.isNewAccount account then modal else span[][]) ] let clipLimitsView model dispatch = diff --git a/src/web/ui/src/Users/State.fs b/src/web/ui/src/Users/State.fs index 8f3ad1ffb..69e47b3e6 100644 --- a/src/web/ui/src/Users/State.fs +++ b/src/web/ui/src/Users/State.fs @@ -85,6 +85,7 @@ let init (context:ServiceContext.ServiceContext) : Model * Cmd = userList = [] accountsList = [] scratchUser = defaultScratchUser + PreviousScratchUser = defaultScratchUser currentTab = Tab.General admin = admin adminData = None @@ -96,13 +97,31 @@ let rec removeUser (user:BTSUser) (userList:BTSUser list) = | hd::tl -> hd::removeUser user tl | _ -> [] -let getCurrentUser (user:BTSUser) (userList:BTSUser list) = - List.tryFind (fun (x:BTSUser) -> x.id = user.id) userList +let getFirstUser usrlst = + let head = (List.sortBy (fun (u:BTSUser) -> u.name.ToLower()) usrlst) |> List.tryHead + match head with + | None -> defaultScratchUser + | Some hd -> hd -let userIsdirty (initialState:BTSUser) (scratch:BTSUser) (existing:BTSUser option) = - match existing with - | None -> (scratch <> initialState) - | Some ex -> (scratch <> ex) && (scratch <> initialState) +let findUserInList (user:BTSUser) (userList:BTSUser list) = + List.tryFind (fun (x:BTSUser) -> + x.id = user.id + || (user.id = 0u && x.name = user.name) + ) + userList + +let getCurrentOrFirstUser (model:Model) (userList:BTSUser list) = + match (findUserInList model.scratchUser userList), (findUserInList model.PreviousScratchUser userList) with + | Some cu, _ -> cu + | None, Some pu -> pu + | None, None -> getFirstUser userList + +let getCurrentUser (model:Model) = getCurrentOrFirstUser model model.userList + + + + +let userIsdirty (initialState:BTSUser) (scratch:BTSUser) (existing:BTSUser) = (scratch <> existing) && (scratch <> initialState) let userIsSelected (initialState:BTSUser) (scratch:BTSUser) = scratch <> initialState @@ -180,16 +199,11 @@ let update msg (model:Users.Types.Model) : Model * Cmd = | UpdateAdminData adm -> let usrlst = Seq.toList (Seq.filter (fun (usr:BTSUser) -> usr.isPresent) adm.users) - let cusr = - match getCurrentUser model.scratchUser usrlst with - | None -> (List.sortBy (fun (u:BTSUser) -> u.name.ToLower()) usrlst).Head - | Some cu -> cu - {model with adminData = Some adm userList = usrlst accountsList = (Seq.toList adm.accounts) - scratchUser = cusr + scratchUser = (getCurrentOrFirstUser model usrlst) }, Cmd.Empty | RpcResponse str -> printf "%s" str @@ -213,16 +227,16 @@ let update msg (model:Users.Types.Model) : Model * Cmd = | false -> model, Cmd.Empty | AddUser -> - { model with scratchUser = { defaultScratchUser with name = "New User" } }, Cmd.ofMsg (SwitchTab General) + { model with PreviousScratchUser = model.scratchUser; scratchUser = { defaultScratchUser with name = "New User" } }, Cmd.ofMsg (SwitchTab General) | SwitchTab tb -> {model with currentTab = tb}, Cmd.Empty | SwitchUser usr -> - { model with scratchUser = usr }, Cmd.Empty + { model with PreviousScratchUser = model.scratchUser; scratchUser = usr }, Cmd.Empty | SaveUser -> // match on id = 0 to see if it's a new user match model.scratchUser.id with - | 0u -> model, Cmd.ofExistingPromise (createUser model.admin model.scratchUser) id (box>>ErrorOccured) + | 0u -> { model with PreviousScratchUser = model.scratchUser}, Cmd.ofExistingPromise (createUser model.admin model.scratchUser) id (box>>ErrorOccured) | _ -> model, Cmd.ofExistingPromise (saveUser model.admin model.scratchUser) id (box>>ErrorOccured) | ErrorOccured msg -> //Browser.console.log msg diff --git a/src/web/ui/src/Users/Types.fs b/src/web/ui/src/Users/Types.fs index 9194ca3a2..86d4fda09 100644 --- a/src/web/ui/src/Users/Types.fs +++ b/src/web/ui/src/Users/Types.fs @@ -13,6 +13,7 @@ type Model = { userList: BTSUser list accountsList: BTSAccount list scratchUser:BTSUser + PreviousScratchUser:BTSUser currentTab:Tab admin : IAdminService adminData : AdminData option diff --git a/src/web/ui/src/Users/View.fs b/src/web/ui/src/Users/View.fs index 635436b26..59c0ce2e3 100644 --- a/src/web/ui/src/Users/View.fs +++ b/src/web/ui/src/Users/View.fs @@ -27,18 +27,28 @@ let isActiveUser id (currentUser:BTSUser) = let saveButton (model:Users.Types.Model) dispatch = let buttonText = if State.isNewAccount model.scratchUser then "Create" else "Save" - let dirty = State.userIsdirty State.defaultScratchUser model.scratchUser (State.getCurrentUser model.scratchUser model.userList) + let dirty = State.userIsdirty State.defaultScratchUser model.scratchUser (State.getCurrentUser model) let enabled = if dirty then Button.Enabled else Button.Disabled let flavor = if dirty then "is-success" else "is-light" Button.button buttonText flavor "" enabled (fun _ -> dispatch SaveUser) let generalTabContent (model:Model) (dispatch:Msg->Unit) = + let modal = Modal.showCreate + "Create User" + (div [][ + Fields.text "Name" model.scratchUser.name [ ] (Name >> UpdateField >> dispatch) + Fields.password "Password" model.scratchUser.password [ ] (Password >> UpdateField >> dispatch) + Fields.checkbox "Active" "Allows the user to login and access information" model.scratchUser.isActive [] (IsActive >> UpdateField >> dispatch) + ]) + (fun _ -> dispatch SaveUser) + (fun _ -> SwitchUser (State.getCurrentUser model) |> dispatch) div [] [ p [ Style [FontWeight "Bold"] ] [ str ("ID: " + model.scratchUser.id.ToString())] br [] Fields.text "Name" model.scratchUser.name [ ] (Name >> UpdateField >> dispatch) Fields.password "Password" model.scratchUser.password [ ] (Password >> UpdateField >> dispatch) Fields.checkbox "Active" "Allows the user to login and access information" model.scratchUser.isActive [] (IsActive >> UpdateField >> dispatch) + (if State.isNewAccount model.scratchUser then modal else span[][]) ] let accountNameLookup (accountsList:BTSAccount list) (id:string) = @@ -216,11 +226,8 @@ let usersMenu (usersList:BTSUser list) (currentUser:BTSUser) (dispatch:Msg->Unit ] let root (model:Model) (dispatch:Msg->Unit) = - let definitelyAUser = - match (State.getCurrentUser model.scratchUser model.userList) with - | Some useThis -> useThis - | None -> State.defaultScratchUser - let dirty = State.userIsdirty State.defaultScratchUser model.scratchUser (State.getCurrentUser model.scratchUser model.userList) + + let dirty = State.userIsdirty State.defaultScratchUser model.scratchUser (State.getCurrentUser model) (match model.adminData with | None -> div[][str "Loading user list..."] @@ -255,7 +262,7 @@ let root (model:Model) (dispatch:Msg->Unit) = div [ ClassName "column is-narrow" ] [ yield saveButton model dispatch - yield Button.button "Revert" "is-light" "" (if dirty then Button.Enabled else Button.Disabled) (fun _ -> SwitchUser definitelyAUser |> dispatch) + yield Button.button "Revert" "is-light" "" (if dirty then Button.Enabled else Button.Disabled) (fun _ -> SwitchUser (State.getCurrentUser model) |> dispatch) ] ] tabContent model dispatch From 27a1cb277c90cdedf7427899f50941fe9db721cd Mon Sep 17 00:00:00 2001 From: Michael Harding Date: Wed, 6 Jun 2018 11:18:21 -0400 Subject: [PATCH 47/68] SPARK-1201: Remove Connections table borders; Add colSpan to table cells --- src/web/ui/sass/main.sass | 10 +- src/web/ui/src/Accounts/View.fs | 156 ++++++++++++------------------- src/web/ui/src/Controls/Table.fs | 8 +- src/web/ui/src/Users/View.fs | 37 ++------ 4 files changed, 81 insertions(+), 130 deletions(-) diff --git a/src/web/ui/sass/main.sass b/src/web/ui/sass/main.sass index 070ca36d1..62dca716f 100644 --- a/src/web/ui/sass/main.sass +++ b/src/web/ui/sass/main.sass @@ -55,4 +55,12 @@ input[type=text].login-input, input[type=password].login-input vertical-align: middle table .fabutton - margin-top: 0.9ex \ No newline at end of file + margin-top: 0.9ex + +.no-border + border: 0 + td + border: 0 + th + border: 0 + \ No newline at end of file diff --git a/src/web/ui/src/Accounts/View.fs b/src/web/ui/src/Accounts/View.fs index 169da4c46..228452809 100644 --- a/src/web/ui/src/Accounts/View.fs +++ b/src/web/ui/src/Accounts/View.fs @@ -91,12 +91,12 @@ let clipLimitsView model dispatch = { cells = [ - { content = str ""; className = ""; isHeader = true } - { content = str "Exchange"; className = ""; isHeader = true } - { content = str "Security Type"; className = ""; isHeader = true } - { content = str "Symbol"; className = ""; isHeader = true } - { content = str "Security"; className = ""; isHeader = true } - { content = str "Clip Size"; className = ""; isHeader = true } + TableControl.Cell (str "") + TableControl.Cell (str "Exchange") + TableControl.Cell (str "Security Type") + TableControl.Cell (str "Symbol") + TableControl.Cell (str "Security") + TableControl.Cell (str "Clip Size") ] className = "" header = None @@ -155,51 +155,41 @@ let clipLimitsView model dispatch = [ for limit in model.scratch.securityClipLimits.limit do yield { cells = [ - { content = Button.fabutton "Remove" "times" Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.securityClipLimits.limit) |> DeleteClipLimit |> dispatch); className = ""; isHeader = false } - { content = Fields.enumSelect + TableControl.Cell (Button.fabutton "Remove" "times" Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.securityClipLimits.limit) |> DeleteClipLimit |> dispatch)) + TableControl.Cell (Fields.enumSelect "" (EnumUtils.toHuman false venues limit.security.exchange) (EnumUtils.allToHuman false venues) [] ((changeVenue limit) >> ClipLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.enumSelect + ) + TableControl.Cell (Fields.enumSelect "" (EnumUtils.toHuman false securityTypes limit.security.securityType) (EnumUtils.allToHuman false securityTypes) [] ((changeType limit) >> ClipLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.enumSelect + ) + TableControl.Cell (Fields.enumSelect "" limit.security.securitySymbol symbolArray [] ((changeSymbol limit) >> ClipLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.mapSelect + ) + TableControl.Cell (Fields.mapSelect "" (JSMap.toMap (getSecurityMap limit)) None (Some (sprintf "%i" limit.security.securityId)) ((changeSecurityId limit) >> ClipLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.text + ) + TableControl.Cell (Fields.text "" (sprintf "%i" limit.clipSize) [ Style [Width "10em"]] ((changeClipSize limit) >> ClipLimits >> dispatch) - className = "" - isHeader = false - } + ) ] className = "" header = None @@ -223,12 +213,12 @@ let productLimits model dispatch = { cells = [ - { content = str ""; className = ""; isHeader = true } - { content = str "Exchange"; className = ""; isHeader = true } - { content = str "Security Type"; className = ""; isHeader = true } - { content = str "Symbol"; className = ""; isHeader = true } - { content = str "Max Net Long Position"; className = ""; isHeader = true } - { content = str "Max Net Short Position"; className = ""; isHeader = true } + TableControl.Cell (str "") + TableControl.Cell (str "Exchange") + TableControl.Cell (str "Security Type") + TableControl.Cell (str "Symbol") + TableControl.Cell (str "Max Net Long Position") + TableControl.Cell (str "Max Net Short Position") ] className = "" header = None @@ -268,50 +258,40 @@ let productLimits model dispatch = [ for limit in model.scratch.productPositionLimits do yield { cells = [ - { content = Button.fabutton "Remove" "times" Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.productPositionLimits) |> DeleteProductLimit |> dispatch); className = ""; isHeader = false } - { content = Fields.enumSelect + TableControl.Cell (Button.fabutton "Remove" "times" Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.productPositionLimits) |> DeleteProductLimit |> dispatch)) + TableControl.Cell (Fields.enumSelect "" (EnumUtils.toHuman false venues limit.product.exchange) (EnumUtils.allToHuman false venues) [] ((changeVenue limit) >> ProductLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.enumSelect + ) + TableControl.Cell (Fields.enumSelect "" (EnumUtils.toHuman false securityTypes limit.product.securityType) (EnumUtils.allToHuman false securityTypes) [] ((changeType limit) >> ProductLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.enumSelect + ) + TableControl.Cell (Fields.enumSelect "" limit.product.securitySymbol symbolArray [] ((changeSymbol limit) >> ProductLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.text + ) + TableControl.Cell (Fields.text "" (sprintf "%i" limit.longPositionLimit) [ Style [Width "10em"]] ((changeLongPositionLimit limit) >> ProductLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.text + ) + TableControl.Cell (Fields.text "" (sprintf "%i" limit.shortPositionLimit) [ Style [Width "10em"]] ((changeShortPositionLimit limit) >> ProductLimits >> dispatch) - className = "" - isHeader = false - } + ) ] className = "" header = None @@ -343,13 +323,13 @@ let securityLimits model dispatch = { cells = [ - { content = str ""; className = ""; isHeader = true } - { content = str "Exchange"; className = ""; isHeader = true } - { content = str "Security Type"; className = ""; isHeader = true } - { content = str "Symbol"; className = ""; isHeader = true } - { content = str "Security"; className = ""; isHeader = true } - { content = str "Max Net Long Position"; className = ""; isHeader = true } - { content = str "Max Net Short Position"; className = ""; isHeader = true } + TableControl.Cell (str "") + TableControl.Cell (str "Exchange") + TableControl.Cell (str "Security Type") + TableControl.Cell (str "Symbol") + TableControl.Cell (str "Security") + TableControl.Cell (str "Max Net Long Position") + TableControl.Cell (str "Max Net Short Position") ] className = "" header = None @@ -411,59 +391,47 @@ let securityLimits model dispatch = [ for limit in model.scratch.securityPositionLimits do yield { cells = [ - { content = Button.fabutton "Remove" "times" Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.securityPositionLimits) |> DeleteSecurityLimit |> dispatch); className = ""; isHeader = false } - { content = Fields.enumSelect + TableControl.Cell (Button.fabutton "Remove" "times" Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.securityPositionLimits) |> DeleteSecurityLimit |> dispatch)) + TableControl.Cell (Fields.enumSelect "" (EnumUtils.toHuman false venues limit.security.exchange) (EnumUtils.allToHuman false venues) [] ((changeVenue limit) >> SecurityLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.enumSelect + ) + TableControl.Cell (Fields.enumSelect "" (EnumUtils.toHuman false securityTypes limit.security.securityType) (EnumUtils.allToHuman false securityTypes) [] ((changeType limit) >> SecurityLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.enumSelect + ) + TableControl.Cell (Fields.enumSelect "" limit.security.securitySymbol symbolArray [] ((changeSymbol limit) >> SecurityLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.mapSelect + ) + TableControl.Cell (Fields.mapSelect "" (JSMap.toMap (getSecurityMap limit)) None (Some (sprintf "%i" limit.security.securityId)) ((changeSecurityId limit) >> SecurityLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.text + ) + TableControl.Cell (Fields.text "" (sprintf "%i" limit.longPositionLimit) [ Style [Width "10em"]] ((changeLongPositionLimit limit) >> SecurityLimits >> dispatch) - className = "" - isHeader = false - } - { content = Fields.text + ) + TableControl.Cell (Fields.text "" (sprintf "%i" limit.shortPositionLimit) [ Style [Width "10em"]] ((changeShortPositionLimit limit) >> SecurityLimits >> dispatch) - className = "" - isHeader = false - } + ) ] className = "" header = None @@ -498,18 +466,10 @@ let ConnectionsView (model:Accounts.Types.Model) dispatch = let rws:TableControl.row list = [for name in conNames do yield { cells = [ - { - content = Button.fabutton "" "times" Button.Enabled (fun _ -> name |> ( RemoveConnection >> dispatch)) - className = "" - isHeader = false - } - { - content = str name - className = "" - isHeader = false - } + (TableControl.Cell (Button.fabutton "" "times" Button.Enabled (fun _ -> name |> ( RemoveConnection >> dispatch)))) + (TableControl.Cell (str name)) ] - className="" + className="no-border" header = None } ] @@ -525,7 +485,7 @@ let ConnectionsView (model:Accounts.Types.Model) dispatch = |> Map.ofArray let rows = - rws @ [{cells = [ {content = Fields.mapSelect "" conMap (Some "Add Connection") None (fun v -> v |> (AddConnection >> dispatch)); className = ""; isHeader = true } ]; className = ""; header = None }] + rws @ [{cells = [ {content = Fields.mapSelect "" conMap (Some "Add Connection") None (fun v -> v |> (AddConnection >> dispatch)); className = ""; isHeader = true; colSpan = 2 } ]; className = "no-border"; header = None }] div [] [ TableControl.createTable None rows diff --git a/src/web/ui/src/Controls/Table.fs b/src/web/ui/src/Controls/Table.fs index 706adb426..977ee54f0 100644 --- a/src/web/ui/src/Controls/Table.fs +++ b/src/web/ui/src/Controls/Table.fs @@ -6,7 +6,9 @@ open Fable.Helpers.React open Fable.Helpers.React.Props open Fable.Import.React -type cell = { content:ReactElement; className:string; isHeader:bool } +type cell = { content:ReactElement; className:string; isHeader:bool; colSpan:int } + +let Cell (content:ReactElement) = { content = content; className = ""; isHeader = false; colSpan = 0 } type row = { cells:cell list @@ -16,8 +18,8 @@ type row = { let createCell (c:cell) = match c.isHeader with - | false -> td [ ClassName c.className ] [ c.content ] - | true -> th [ ClassName c.className ] [ c.content ] + | false -> td [ ClassName c.className; ColSpan (float c.colSpan) ] [ c.content ] + | true -> th [ ClassName c.className; ColSpan (float c.colSpan) ] [ c.content ] let createRow (r:row) = match r.header with diff --git a/src/web/ui/src/Users/View.fs b/src/web/ui/src/Users/View.fs index 59c0ce2e3..affa1b735 100644 --- a/src/web/ui/src/Users/View.fs +++ b/src/web/ui/src/Users/View.fs @@ -66,10 +66,10 @@ let accountsTabContent (model:Model) (dispatch:Msg->Unit) = { cells = [ - { content = str ""; className = ""; isHeader = true } - { content = str "Account"; className = ""; isHeader = true } - { content = str "Trading Permission"; className = ""; isHeader = true } - { content = str "Admin Permission"; className = ""; isHeader = true } + TableControl.Cell(str "") + TableControl.Cell(str "Account") + TableControl.Cell(str "Trading Permission") + TableControl.Cell(str "Admin Permission") ] className = "" header = None @@ -77,26 +77,10 @@ let accountsTabContent (model:Model) (dispatch:Msg->Unit) = let rws:TableControl.row list = [for (key,name) in keys do yield { cells = [ - { - content = Button.fabutton "" "times" Button.Enabled (fun _ -> key |> (RemoveAccount >> UpdateField >> dispatch)) - className = "" - isHeader = false - } - { - content = str name - className = "" - isHeader = false - } - { - content = str "Full" - className = "" - isHeader = false - } - { - content = str "Full" - className = "" - isHeader = false - } + TableControl.Cell(Button.fabutton "" "times" Button.Enabled (fun _ -> key |> (RemoveAccount >> UpdateField >> dispatch))) + TableControl.Cell(str name) + TableControl.Cell( str "Full") + TableControl.Cell(str "Full") ] className="" header = None @@ -112,10 +96,7 @@ let accountsTabContent (model:Model) (dispatch:Msg->Unit) = let rows = rws @ [{cells = [ - { content = str ""; className = ""; isHeader = true } - {content = Fields.mapSelect "" accMap (Some "Add Account") None (AddAccount >> UpdateField >> dispatch); className = ""; isHeader = true } - { content = str ""; className = ""; isHeader = true } - { content = str ""; className = ""; isHeader = true } + { content = Fields.mapSelect "" accMap (Some "Add Account") None (AddAccount >> UpdateField >> dispatch); className = ""; isHeader = false; colSpan = 4 } ]; className = ""; header = None }] div [] From 59d88d3cc1c32d793cd934d9c0f631a55e169602 Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Wed, 6 Jun 2018 12:32:13 -0400 Subject: [PATCH 48/68] colors per Michael --- src/client/spark/core/FontsAndColors/BTSColors.cs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/client/spark/core/FontsAndColors/BTSColors.cs b/src/client/spark/core/FontsAndColors/BTSColors.cs index eabf1ed35..407deaca3 100644 --- a/src/client/spark/core/FontsAndColors/BTSColors.cs +++ b/src/client/spark/core/FontsAndColors/BTSColors.cs @@ -199,10 +199,10 @@ namespace mbts.ui { public static BTSColor straddle_theovsmarket_positive { get { return BTSCoreColors.green_light; } } // Order Types - public static BTSColor tick_order { get { return new BTSColor(31, 4, 57);}} - public static BTSColor lean_order { get { return new BTSColor(110, 77, 143);}} - public static BTSColor join_order { get { return new BTSColor(15, 1, 29);}} - public static BTSColor top_order { get { return new BTSColor(40, 9, 72);}} + public static BTSColor tick_order { get { return BTSColors.purple.rgb_color();}} + public static BTSColor lean_order { get { return BTSColors.purple.rgb_color();}} + public static BTSColor join_order { get { return BTSColors.purple.rgb_color();}} + public static BTSColor top_order { get { return BTSColors.purple.rgb_color();}} } public static class AW2 { From 203998e20188142d2e9f64f8b268e93bb401dcf0 Mon Sep 17 00:00:00 2001 From: Pete Date: Wed, 6 Jun 2018 12:40:25 -0400 Subject: [PATCH 49/68] change default secure CME login to true --- src/lib/config/protos/jetfix.proto | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/lib/config/protos/jetfix.proto b/src/lib/config/protos/jetfix.proto index 731e71be5..023756a0d 100644 --- a/src/lib/config/protos/jetfix.proto +++ b/src/lib/config/protos/jetfix.proto @@ -1,4 +1,4 @@ -syntax='proto2'; +\syntax='proto2'; package bts.config; message JetFIX { @@ -77,7 +77,7 @@ message JetFIX { optional string trading_session_id = 330 [default=""]; optional int32 udf_support_indicator = 340 [default=1]; - optional bool use_cme_secure_logon = 341 [default=false]; + optional bool use_cme_secure_logon = 341 [default=true]; optional bool auto_cert_mode = 342 [default=false]; } From 83b1bbf087d47f650dfb0c387e229e5198fe522c Mon Sep 17 00:00:00 2001 From: Jake Norbut Date: Wed, 6 Jun 2018 11:44:58 -0500 Subject: [PATCH 50/68] PR suggestions --- src/client/spark/view/Spark/Ladder/LadderVM.cs | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/client/spark/view/Spark/Ladder/LadderVM.cs b/src/client/spark/view/Spark/Ladder/LadderVM.cs index ec89d8b32..5fd8a4a83 100644 --- a/src/client/spark/view/Spark/Ladder/LadderVM.cs +++ b/src/client/spark/view/Spark/Ladder/LadderVM.cs @@ -73,7 +73,6 @@ namespace mbts.spark { model.order_gateway.working_orders.ObserveOnDispatcher().Subscribe(working => { // Here we manage N orders to 1 price slot in the ladder - HashSet prices_used_in_this_update = new HashSet(); Dictionary> orders_used_in_this_update = new Dictionary>(); var ladders_orders = working.Values.Where(o => o.Def.SecurityKey == security.Id); foreach (var wo in ladders_orders) { @@ -89,9 +88,7 @@ namespace mbts.spark { if (filled == 0) { slot_price_target = wo.stop_limit_price(); } } - prices_used_in_this_update.Add(slot_price_target); - _slot_price_vs_orders.TryGetValue(slot_price_target, out LadderOrderVM slot_vm); - if (slot_vm != null) { + if (_slot_price_vs_orders.TryGetValue(slot_price_target, out LadderOrderVM slot_vm)) { slot_vm.add_order(wo); } else { slot_vm = new LadderOrderVM(wo, slot_price_target, this, _bus, _settings_manager.subscribe_current().Select(s => s.badge_style)); @@ -100,8 +97,7 @@ namespace mbts.spark { // keep track of slot prices vs orders; we use this below to remove orders from the LadderOrderVMs // that are not found in this callback run - orders_used_in_this_update.TryGetValue(slot_price_target, out HashSet orders_at_level); - if (orders_at_level == null) { + if (!orders_used_in_this_update.TryGetValue(slot_price_target, out HashSet orders_at_level)) { orders_at_level = new HashSet(); } orders_at_level.Add(wo.Key); @@ -126,8 +122,9 @@ namespace mbts.spark { } // complete removal of slots that were not updated + // orders_used_in_this_update.Keys are the price levels in the update foreach (var slot_price in _slot_price_vs_orders.Keys.ToList()) { - if (!prices_used_in_this_update.Contains(slot_price)) { + if (!orders_used_in_this_update.Keys.Contains(slot_price)) { _slot_price_vs_orders.TryGetValue(slot_price, out LadderOrderVM removal_candidate); if (removal_candidate != null) { removal_candidate.Dispose(); From 56950b682d46a6f2a886d2dc3c1b820f47d7b4ba Mon Sep 17 00:00:00 2001 From: Pete Date: Wed, 6 Jun 2018 13:00:45 -0400 Subject: [PATCH 51/68] fat fingered --- src/lib/config/protos/jetfix.proto | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/lib/config/protos/jetfix.proto b/src/lib/config/protos/jetfix.proto index 023756a0d..e54d40247 100644 --- a/src/lib/config/protos/jetfix.proto +++ b/src/lib/config/protos/jetfix.proto @@ -1,4 +1,4 @@ -\syntax='proto2'; +syntax='proto2'; package bts.config; message JetFIX { From 50214741e77326f1bf0875c19aeaefd17c4e3bc8 Mon Sep 17 00:00:00 2001 From: Jake Norbut Date: Wed, 6 Jun 2018 12:31:22 -0500 Subject: [PATCH 52/68] PR - backings for a lazy life --- .../spark/view/Spark/Ladder/LadderOrderVM.cs | 35 +++++-------------- 1 file changed, 8 insertions(+), 27 deletions(-) diff --git a/src/client/spark/view/Spark/Ladder/LadderOrderVM.cs b/src/client/spark/view/Spark/Ladder/LadderOrderVM.cs index f906cadb6..dd255c5f5 100644 --- a/src/client/spark/view/Spark/Ladder/LadderOrderVM.cs +++ b/src/client/spark/view/Spark/Ladder/LadderOrderVM.cs @@ -16,6 +16,7 @@ namespace mbts.spark { class LadderOrderVM : DisposableViewModelBase { #region Colors static readonly Color _colorbg = Colors.White, _darkbg = Color.FromRgb(0xbf, 0xbf, 0xbf); + static readonly Brush _color_bg_brush = _colorbg.rgb_color().rgb_brush(); static Brush mkbrush(Color color, Color endcolor, double pct_complete) { GradientStopCollection stops = new GradientStopCollection(); stops.Add(new GradientStop(color, 0.0)); @@ -34,7 +35,7 @@ namespace mbts.spark { readonly Property _font_family; readonly Property _font_weight; readonly Property _font_size; - readonly Property _foreground; + readonly Property _foreground, _background, _hoverbackground, _border; IObservable _bs; LadderSettings.BadgeStyle _current_badge_style; int _n_active_price_change_ops = 0; @@ -56,6 +57,9 @@ namespace mbts.spark { _font_weight = backing(nameof(font_weight), parent.settings, get_font_weight, get_font_weight(fs)); _font_size = backing(nameof(font_size), parent.settings, get_font_size, get_font_size(fs)); _foreground = backing(nameof(foreground), parent.settings, get_foreground, get_foreground(fs)); + _background = backing(nameof(background), _color_bg_brush); + _hoverbackground = backing(nameof(hoverbackground), _color_bg_brush); + _border = backing(nameof(border), _color_bg_brush); FontFamily get_font_family(LadderSettings s) => new FontFamily(s.orders_column.font_family); FontWeight get_font_weight(LadderSettings s) => ui.utility.text.TextUtils.from_open_type_weight_safe(s.orders_column.font_weight); double get_font_size(LadderSettings s) => s.orders_column.font_size; @@ -209,32 +213,9 @@ namespace mbts.spark { public FontWeight font_weight => _font_weight.Value; public double font_size => _font_size.Value; public Brush foreground => _foreground.Value; - - private Brush _background; - public Brush background { - get { return _background; } - private set { - _background = value; - RaisePropertyChanged(); - } - } - private Brush _hoverbackground; - public Brush hoverbackground { - get { return _hoverbackground; } - private set { - _hoverbackground = value; - RaisePropertyChanged(); - } - } - - private Brush _border; - public Brush border { - get { return _border; } - private set { - _border = value; - RaisePropertyChanged(); - } - } + public Brush background { get; private set; } + public Brush hoverbackground { get; private set; } + public Brush border { get; private set; } public IEnumerable orders => _orders.Values; void _cancel_order() { From 6d2efb7dc9af469167728fdc761108d72f544aeb Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Wed, 6 Jun 2018 13:34:05 -0400 Subject: [PATCH 53/68] clarified min_initial_tick_offset --- .../spark/Orders/OrderTypeVMs/JoinOrderVM.cs | 14 ++++++------ .../spark/Orders/OrderTypeVMs/TickOrderVM.cs | 14 ++++++------ .../Order/OrderDetailsPopupControl.xaml | 8 +++---- src/lib/api/services/OrderService.proto | 4 ++-- .../orderman/orders/book_algos/JoinOrder.cpp | 22 ++++++++++--------- .../orderman/orders/book_algos/TickOrder.cpp | 22 ++++++++++--------- 6 files changed, 44 insertions(+), 40 deletions(-) diff --git a/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs index 185018df1..af3989e3a 100644 --- a/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs @@ -28,7 +28,7 @@ namespace mbts.spark this.selected_hedge_order_type = new InlineUserProperty(hedgetype, true); this.hedge_order_types = new InlineUserProperty>(child_order_types, true); - min_tick_offset_on_deploy = new InlineUserProperty(0, false); + tick_offset_on_deploy = new InlineUserProperty(0, false); join_threshold = new InlineUserProperty( new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false); enable_hedge = new InlineUserProperty(false, false); @@ -40,7 +40,7 @@ namespace mbts.spark public readonly InlineUserProperty> hedge_order_types; - public readonly InlineUserProperty min_tick_offset_on_deploy; + public readonly InlineUserProperty tick_offset_on_deploy; public readonly InlineUserProperty join_threshold; public readonly InlineUserProperty enable_hedge; @@ -62,7 +62,7 @@ namespace mbts.spark IOrderTypeVM _hedge_order; IDisposable _hedge_order_errors_sub; - public uint min_tick_offset_on_deploy { get; set; } = 0; + public uint tick_offset_on_deploy { get; set; } = 0; public bts.spark.QuantityMeasure join_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; bool _enable_hedge = false; public bool enable_hedge @@ -101,10 +101,10 @@ namespace mbts.spark { _select_hedge_order(p.selected_hedge_order_type.value); } - if (p.min_tick_offset_on_deploy.force_override) + if (p.tick_offset_on_deploy.force_override) { - min_tick_offset_on_deploy = p.min_tick_offset_on_deploy.value; - RaisePropertyChanged(nameof(min_tick_offset_on_deploy)); + tick_offset_on_deploy = p.tick_offset_on_deploy.value; + RaisePropertyChanged(nameof(tick_offset_on_deploy)); } if (p.join_threshold.force_override) { @@ -138,7 +138,7 @@ namespace mbts.spark if (!HasErrors) { var i = factory.join_order(); - i.MinTickOffsetOnDeploy = min_tick_offset_on_deploy; + i.TickOffsetOnDeploy = tick_offset_on_deploy; i.JoinThreshold = join_threshold; i.EnableHedge = enable_hedge; i.HedgeTicks = hedge_ticks; diff --git a/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs index 7881fb6d8..afde6e6ca 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs @@ -22,7 +22,7 @@ namespace mbts.spark ExceptionAssert.InvalidOperation.That(child_order_types.Contains(selected_child_order_type), $"Child order type {selected_child_order_type} is not in child_order_types"); this.selected_child_order_type = new InlineUserProperty(selected_child_order_type, true); this.child_order_types = new InlineUserProperty>(child_order_types, true); - min_tick_offset_on_deploy = new InlineUserProperty(0, false); + tick_offset_on_deploy = new InlineUserProperty(0, false); cross_threshold = new InlineUserProperty( new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1}, false); cross_ticks = new InlineUserProperty(0, false); @@ -32,7 +32,7 @@ namespace mbts.spark public readonly InlineUserProperty selected_child_order_type; public readonly InlineUserProperty> child_order_types; - public readonly InlineUserProperty min_tick_offset_on_deploy; + public readonly InlineUserProperty tick_offset_on_deploy; public readonly InlineUserProperty cross_threshold; public readonly InlineUserProperty cross_ticks; public readonly InlineUserProperty max_chase_ticks; @@ -49,7 +49,7 @@ namespace mbts.spark IOrderTypeVM _child_order; IDisposable _dispose, _child_order_errors_sub; - public uint min_tick_offset_on_deploy { get; set; } = 0; + public uint tick_offset_on_deploy { get; set; } = 0; public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; public uint cross_ticks { get; set; } = 0; public uint max_chase_ticks { get; set; } = 10; @@ -76,10 +76,10 @@ namespace mbts.spark { _select_child_order(p.selected_child_order_type.value); } - if (p.min_tick_offset_on_deploy.force_override) + if (p.tick_offset_on_deploy.force_override) { - min_tick_offset_on_deploy = p.min_tick_offset_on_deploy.value; - RaisePropertyChanged(nameof(min_tick_offset_on_deploy)); + tick_offset_on_deploy = p.tick_offset_on_deploy.value; + RaisePropertyChanged(nameof(tick_offset_on_deploy)); } if (p.cross_threshold.force_override) { @@ -116,7 +116,7 @@ namespace mbts.spark if (!HasErrors) { var i = factory.tick_order(); - i.MinTickOffsetOnDeploy = min_tick_offset_on_deploy; + i.TickOffsetOnDeploy = tick_offset_on_deploy; i.CrossThreshold = cross_threshold; i.CrossTicks = cross_ticks; i.MaxChaseTicks = max_chase_ticks; diff --git a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml index 6041ee7ec..e5d910940 100644 --- a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml +++ b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml @@ -188,8 +188,8 @@ Max Chase Ticks Detach on Toward - Min Initial Tick Offset - + Initial Tick Offset + Child - Min Initial Tick Offset - + Initial Tick Offset + Child mutable_custom_def() = join_def.child(); - me->min_tick_offset_on_deploy = join_def.min_tick_offset_on_deploy(); + me->tick_offset_on_deploy = join_def.tick_offset_on_deploy(); me->join_threshold = join_def.join_threshold(); me->enable_hedge = join_def.enable_hedge(); me->hedge_ticks = join_def.hedge_ticks(); @@ -86,11 +86,12 @@ void JoinOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) { if(definition().side() == api::SIDE_BUY) { - me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0]; - double max_price = me->opposite_at_inception.price() - tick_size() * me->min_tick_offset_on_deploy; - if(me->min_tick_offset_on_deploy && this_state().price() > max_price) + me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0]; + if(me->tick_offset_on_deploy > 0) { - set_price(max_price); + double price = me->opposite_at_inception.price() - tick_size() * me->tick_offset_on_deploy; + activate_child(Price(price), Quantity(this_state().quantity())); + transition(ORDER_STATUS_WORKING); } else { @@ -100,11 +101,12 @@ void JoinOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) } else { - me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0]; - double min_price = me->opposite_at_inception.price() + tick_size() * me->min_tick_offset_on_deploy; - if(me->min_tick_offset_on_deploy && this_state().price() < min_price) + me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0]; + if(me->tick_offset_on_deploy > 0) { - set_price(min_price); + double price = me->opposite_at_inception.price() + tick_size() * me->tick_offset_on_deploy; + activate_child(Price(price), Quantity(this_state().quantity())); + transition(ORDER_STATUS_WORKING); } else { diff --git a/src/server/sparkd/orderman/orders/book_algos/TickOrder.cpp b/src/server/sparkd/orderman/orders/book_algos/TickOrder.cpp index c72fa3468..15872dcf5 100644 --- a/src/server/sparkd/orderman/orders/book_algos/TickOrder.cpp +++ b/src/server/sparkd/orderman/orders/book_algos/TickOrder.cpp @@ -14,7 +14,7 @@ struct TickOrder::PImpl { PImpl() {} - uint32_t min_tick_offset_on_deploy; + uint32_t tick_offset_on_deploy; spark::QuantityMeasure cross_threshold; uint32_t cross_ticks; uint32_t max_chase_ticks; @@ -35,7 +35,7 @@ void TickOrder::setup_child(const api::orderman::OrderDefinition& this_def, cons auto const &tick_def = this_def.custom_def().tick(); *out_child->mutable_custom_def() = tick_def.child(); - me->min_tick_offset_on_deploy = tick_def.min_tick_offset_on_deploy(); + me->tick_offset_on_deploy = tick_def.tick_offset_on_deploy(); me->cross_threshold = tick_def.cross_threshold(); me->cross_ticks = tick_def.cross_ticks(); me->max_chase_ticks = tick_def.max_chase_ticks(); @@ -82,11 +82,12 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) { if(definition().side() == api::SIDE_BUY) { - me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0]; - double max_price = me->opposite_at_inception.price() - tick_size() * me->min_tick_offset_on_deploy; - if(me->min_tick_offset_on_deploy && this_state().price() > max_price) + me->opposite_at_inception = book.book.side(api::Side::SIDE_SELL)[0]; + if(me->tick_offset_on_deploy > 0) { - set_price(max_price); + double price = me->opposite_at_inception.price() - tick_size() * me->tick_offset_on_deploy; + activate_child(Price(price), Quantity(this_state().quantity())); + transition(ORDER_STATUS_WORKING); } else { @@ -96,11 +97,12 @@ void TickOrder::on_book_update(const bts::orderman::BookUpdateEvent& book) } else { - me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0]; - double min_price = me->opposite_at_inception.price() + tick_size() * me->min_tick_offset_on_deploy; - if(me->min_tick_offset_on_deploy && this_state().price() < min_price) + me->opposite_at_inception = book.book.side(api::Side::SIDE_BUY)[0]; + if(me->tick_offset_on_deploy > 0) { - set_price(min_price); + double price = me->opposite_at_inception.price() + tick_size() * me->tick_offset_on_deploy; + activate_child(Price(price), Quantity(this_state().quantity())); + transition(ORDER_STATUS_WORKING); } else { From 5254b7367afd73cfbc2fa2e758a23a8bd2803fc4 Mon Sep 17 00:00:00 2001 From: Jake Norbut Date: Wed, 6 Jun 2018 13:52:50 -0500 Subject: [PATCH 54/68] PR suggestions; changing summary and description to backings as well since the tooltip was not changing as the lovm updated --- .../spark/view/Spark/Ladder/LadderOrderVM.cs | 19 +++++++++++-------- .../spark/view/Spark/Ladder/LadderVM.cs | 2 +- 2 files changed, 12 insertions(+), 9 deletions(-) diff --git a/src/client/spark/view/Spark/Ladder/LadderOrderVM.cs b/src/client/spark/view/Spark/Ladder/LadderOrderVM.cs index dd255c5f5..17eb0c159 100644 --- a/src/client/spark/view/Spark/Ladder/LadderOrderVM.cs +++ b/src/client/spark/view/Spark/Ladder/LadderOrderVM.cs @@ -36,6 +36,7 @@ namespace mbts.spark { readonly Property _font_weight; readonly Property _font_size; readonly Property _foreground, _background, _hoverbackground, _border; + readonly Property _summary, _description; IObservable _bs; LadderSettings.BadgeStyle _current_badge_style; int _n_active_price_change_ops = 0; @@ -60,6 +61,8 @@ namespace mbts.spark { _background = backing(nameof(background), _color_bg_brush); _hoverbackground = backing(nameof(hoverbackground), _color_bg_brush); _border = backing(nameof(border), _color_bg_brush); + _summary = backing(nameof(summary), string.Empty); + _description = backing(nameof(description), string.Empty); FontFamily get_font_family(LadderSettings s) => new FontFamily(s.orders_column.font_family); FontWeight get_font_weight(LadderSettings s) => ui.utility.text.TextUtils.from_open_type_weight_safe(s.orders_column.font_weight); double get_font_size(LadderSettings s) => s.orders_column.font_size; @@ -97,6 +100,9 @@ namespace mbts.spark { working_quantity = _parent_and_child_not_sharing_slot().Select(order => order.working_quantity()).Sum(); quantity = _parent_and_child_not_sharing_slot().Select(order => order.State.Quantity).Sum(); + summary = _orders.Values.Select(order => order.short_description(_parent.security.ContractSpec)).Aggregate((s1, s2) => $"{s1}{Environment.NewLine}{Environment.NewLine}{s2}"); + description = _orders.Values.Select(order => order.full_description(_parent.security)).Aggregate((s1, s2) => $"{s1}{Environment.NewLine}{Environment.NewLine}{s2}"); + _set_badge_text(); } @@ -116,12 +122,10 @@ namespace mbts.spark { public void add_order(OrderRecordImmutable new_order) { _orders[new_order.Key] = new_order; - is_dirty = true; } public void remove_order(uint order_key) { _orders.Remove(order_key); - is_dirty = true; } //public void update(OrderRecordImmutable neworder) { @@ -131,7 +135,6 @@ namespace mbts.spark { // } //} - public bool is_dirty { get; private set; } public uint security_key => _parent.security.Id; public double price { get => double.IsNaN(_phantom_price) ? _real_price : _phantom_price; } public double real_price => _real_price; @@ -195,8 +198,6 @@ namespace mbts.spark { } } - public string summary => _orders.Values.Select(order => order.short_description(_parent.security.ContractSpec)).Aggregate((s1, s2) => $"{s1}{Environment.NewLine}{Environment.NewLine}{s2}"); - public string description => _orders.Values.Select(order => order.full_description(_parent.security)).Aggregate((s1, s2) => $"{s1}{Environment.NewLine}{Environment.NewLine}{s2}"); public bool has_parent => _orders.Values.Any( order => order.has_parent()); public bool has_phantom_price => !double.IsNaN(_phantom_price); @@ -213,9 +214,11 @@ namespace mbts.spark { public FontWeight font_weight => _font_weight.Value; public double font_size => _font_size.Value; public Brush foreground => _foreground.Value; - public Brush background { get; private set; } - public Brush hoverbackground { get; private set; } - public Brush border { get; private set; } + public Brush background { get => _background.Value; private set => _background.Value = value; } + public Brush hoverbackground { get => _hoverbackground.Value; private set => _hoverbackground.Value = value; } + public Brush border { get => _border.Value; private set => _border.Value = value; } + public string summary { get => _summary.Value; private set => _summary.Value = value; } + public string description { get => _description.Value; private set => _description.Value = value; } public IEnumerable orders => _orders.Values; void _cancel_order() { diff --git a/src/client/spark/view/Spark/Ladder/LadderVM.cs b/src/client/spark/view/Spark/Ladder/LadderVM.cs index 5fd8a4a83..2cc693f00 100644 --- a/src/client/spark/view/Spark/Ladder/LadderVM.cs +++ b/src/client/spark/view/Spark/Ladder/LadderVM.cs @@ -117,7 +117,7 @@ namespace mbts.spark { // update dirty brushes and text - foreach (var lovm in _slot_price_vs_orders.Values.Where(lovm => lovm.is_dirty)) { + foreach (var lovm in _slot_price_vs_orders.Values) { lovm.update(); } From de312c30236dd5bdf798f6c53a2215e3d079e8fb Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Wed, 6 Jun 2018 15:45:48 -0400 Subject: [PATCH 55/68] Update c# language version to 7.2 --- src/client/spark/Spark.csproj | 2 +- src/client/spark_api/spark_api.csproj | 1 + src/client/sparkcmd/sparkcmd.csproj | 1 + 3 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/client/spark/Spark.csproj b/src/client/spark/Spark.csproj index f5d68f735..c549c2d95 100644 --- a/src/client/spark/Spark.csproj +++ b/src/client/spark/Spark.csproj @@ -15,7 +15,7 @@ WinExe mbts.ui.shell.App bts - 7.1 + 7.2 true 1.0.0 diff --git a/src/client/spark_api/spark_api.csproj b/src/client/spark_api/spark_api.csproj index 57fe9e5c9..fbb1f6778 100644 --- a/src/client/spark_api/spark_api.csproj +++ b/src/client/spark_api/spark_api.csproj @@ -11,6 +11,7 @@ true 1.0.0 + 7.2 diff --git a/src/client/sparkcmd/sparkcmd.csproj b/src/client/sparkcmd/sparkcmd.csproj index ffab95cda..1bf66d16d 100644 --- a/src/client/sparkcmd/sparkcmd.csproj +++ b/src/client/sparkcmd/sparkcmd.csproj @@ -10,6 +10,7 @@ x64 AnyCPU 1.0.0 + 7.2 From c10a4be4113928cb3f5938450234650e1f65a0c0 Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Wed, 6 Jun 2018 15:48:32 -0400 Subject: [PATCH 56/68] fixing crash on spreader; the VMs get created no matter what security type, they're filtered later --- src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs | 5 ++++- src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs | 3 ++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs index af3989e3a..af9bde098 100644 --- a/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/JoinOrderVM.cs @@ -24,7 +24,10 @@ namespace mbts.spark this.child_order_types = new InlineUserProperty>(child_order_types, true); var hedgetype = CustomOneofCase.Lean; - ExceptionAssert.InvalidOperation.That(child_order_types.Contains(hedgetype), $"Hedge order type {hedgetype} is not in hedge_order_types"); + if(!child_order_types.Contains(hedgetype)) + hedgetype = CustomOneofCase.Limit; + + //ExceptionAssert.InvalidOperation.That(child_order_types.Contains(hedgetype), $"Hedge order type {hedgetype} is not in hedge_order_types"); this.selected_hedge_order_type = new InlineUserProperty(hedgetype, true); this.hedge_order_types = new InlineUserProperty>(child_order_types, true); diff --git a/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs index 526cb5a35..d96b255cd 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs @@ -24,7 +24,8 @@ namespace mbts.spark this.child_order_types = new InlineUserProperty>(child_order_types, true); var hedgetype = CustomOneofCase.Lean; - ExceptionAssert.InvalidOperation.That(child_order_types.Contains(hedgetype), $"Hedge order type {hedgetype} is not in hedge_order_types"); + if(!child_order_types.Contains(hedgetype)) + hedgetype = CustomOneofCase.Limit; this.selected_hedge_order_type = new InlineUserProperty(hedgetype, true); this.hedge_order_types = new InlineUserProperty>(child_order_types, true); From b25f5556afb5b4fb3c8ec9af5af02b9418b6db20 Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Wed, 6 Jun 2018 15:54:37 -0400 Subject: [PATCH 57/68] added python27 to front of the path in vscode.cmd --- tools/vscode.cmd | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tools/vscode.cmd b/tools/vscode.cmd index 3c1d95db6..7c1f5de87 100644 --- a/tools/vscode.cmd +++ b/tools/vscode.cmd @@ -3,4 +3,6 @@ setlocal cd %~dp0\.. call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\Common7\Tools\VsDevCmd.bat" > nul cd /d %~dp0\.. +setlocal +set path=c:\python27;%path% cmd /C start "" "C:\Program Files\Microsoft VS Code\Code.exe" "%*" -n From 1ad57dbf453697e757fc1d201fb0fff64edb92ce Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Wed, 6 Jun 2018 15:13:51 -0400 Subject: [PATCH 58/68] Instrumenting server side for performance tracking. --- .../md/platforms/mdp3_onixs/MDP3Listener.cpp | 38 +++++++++++++++++-- 1 file changed, 34 insertions(+), 4 deletions(-) diff --git a/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp b/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp index 44bbb7fc5..172729d8f 100644 --- a/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp +++ b/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp @@ -1,6 +1,7 @@ #include "MDP3Listener.h" #include "lib/utils/datetime.h" #include +#include "server/sparkd/tracing/bts_trace.h" using namespace std; using namespace bts::co2; @@ -104,15 +105,19 @@ MDP3Listener::~MDP3Listener() { // // Warnings/Errors void MDP3Listener::onError(onixs::Handler&, const onixs::ErrorArgs& error) { + tracepoint (bts_trace,trace_order,(char*) "onError", 0, _latest_sequence); LOG(md,Warn, "OnixS Error: {} - {}", error.description(), error.source()); } void MDP3Listener::onWarning(onixs::Handler&, const onixs::WarningArgs& warning) { + tracepoint (bts_trace,trace_order,(char*) "onWarning", 0, _latest_sequence); LOG(md,Warn, "OnixS Warn: {} - {}", warning.description(), warning.source()); } void MDP3Listener::onInstrumentRecovery(onixs::Handler& h) { + tracepoint (bts_trace,trace_order,(char*) "onInstrumentRecovery", 0, _latest_sequence); LOG(md,Info, "Beginning security definition recovery for channel {}", h.settings().channel()); } void MDP3Listener::onEndOfInstrumentRecovery(onixs::Handler& h, const onixs::RecoveryCompletionArgs&) { + tracepoint (bts_trace,trace_order,(char*) "onEndOfInstrumentRecovery", 0, _latest_sequence); LOG(md,Info, "Finished Security definition recovery for channel {}", h.settings().channel()); } // void MDP3Listener::onGap(onixs::Handler& h, const Security&, unsigned) { @@ -123,18 +128,22 @@ void MDP3Listener::onEndOfInstrumentRecovery(onixs::Handler& h, const onixs::Rec // // Gap Recovery void MDP3Listener::onMarketRecovery(onixs::Handler& h) { + tracepoint (bts_trace,trace_order,(char*) "onMarketRecovery", 0, _latest_sequence); update_all_status(COCONUTSECURITYSTATUS_PACKET_LOSS); LOG(md,Info, "Beginning market recovery for channel {}", h.settings().channel()); } void MDP3Listener::onEndOfMarketRecovery(onixs::Handler& h, const onixs::RecoveryCompletionArgs&) { + tracepoint (bts_trace,trace_order,(char*) "onEndOfMarketRecovery", 0, _latest_sequence); update_all_status(COCONUTSECURITYSTATUS_OK); LOG(md,Info, "Finished market recovery for channel {}", h.settings().channel()); } void MDP3Listener::onTcpRecovery(onixs::Handler& h) { + tracepoint (bts_trace,trace_order,(char*) "onTcpRecovery", 0, _latest_sequence); update_all_status(COCONUTSECURITYSTATUS_PACKET_LOSS); LOG(md,Info, "Beginning tcp recovery for channel {}", h.settings().channel()); } void MDP3Listener::onEndOfTcpRecovery(onixs::Handler& h, const onixs::RecoveryCompletionArgs&) { + tracepoint (bts_trace,trace_order,(char*) "onEndOfTcpRecovery", 0, _latest_sequence); update_all_status(COCONUTSECURITYSTATUS_OK); LOG(md,Info, "Finished tcp recovery for channel {}", h.settings().channel()); } @@ -152,9 +161,12 @@ void MDP3Listener::onPacket(onixs::Handler&, const onixs::PacketArgs& args) { } } _latest_sequence = seq; + tracepoint (bts_trace,trace_order,(char*) "onPacket", 0,_latest_sequence); } void MDP3Listener::onEndOfPacket(onixs::Handler&, const onixs::PacketArgs&) { + tracepoint (bts_trace,trace_order,(char*) "onEndOfPacket.begin", 0,_latest_sequence); flush_books(); + tracepoint (bts_trace,trace_order,(char*) "onEndOfPacket.end", 0,_latest_sequence); } // @@ -208,6 +220,7 @@ void set_security_common(const Definition& def, FixedSecurity& fsec) { } void MDP3Listener::onDefinition(onixs::Handler&, const onixs::Security& osec, const onixs::InstrumentDefinitionFutureArgs& def) { + tracepoint (bts_trace,trace_order,(char*) "onDefinition.future", 0,_latest_sequence); const auto& sec = def.message(); auto exchange_id = sec.securityId(); // LOG(Info, MarketData) << "onDefinition future " << exchange_id; @@ -232,6 +245,7 @@ void MDP3Listener::onDefinition(onixs::Handler&, const onixs::Security& osec, co add_security(fsec); } void MDP3Listener::onDefinition(onixs::Handler&, const onixs::Security&, const onixs::InstrumentDefinitionOptionArgs& def) { + tracepoint (bts_trace,trace_order,(char*) "onDefinition.option", 0,_latest_sequence); const auto& sec = def.message(); auto exchange_id = sec.securityId(); // LOG(Info, MarketData) << "onDefinition option " << exchange_id; @@ -264,7 +278,7 @@ void MDP3Listener::onDefinition(onixs::Handler&, const onixs::Security&, const o } void MDP3Listener::onDefinition(onixs::Handler&, const onixs::Security&, const onixs::InstrumentDefinitionSpreadArgs& spread_args) { - // tracepoint (bts_trace,quoter,(char*) "onSecurityDefnition", 0, _latest_sequence); + tracepoint (bts_trace,trace_order,(char*) "onDefinition.spread", 0,_latest_sequence); const auto& sec = spread_args.message(); auto exchange_id = sec.securityId(); // LOG(Info, MarketData) << "onDefinition spread " << exchange_id; @@ -309,14 +323,13 @@ void MDP3Listener::onDefinition(onixs::Handler&, const onixs::Security&, const o } add_security(fsec); _index.add_spread_legs(fsec.numeric_id, leg_exchange_ids); - // tracepoint (bts_trace,quoter,(char*) "onSecurityDefnition", 1, _latest_sequence); } // // Book void MDP3Listener::onBookUpdate(onixs::Handler&, const onixs::Security& sec, const onixs::ConsolidatedBook& book) { - // tracepoint (bts_trace,quoter,(char*) "onConsolidatedBookBegin", sec.id(), _latest_sequence); + tracepoint (bts_trace,trace_order,(char*) "onBookUpdate", 0,_latest_sequence); auto data = _index.get_security(sec.id()); if (data == nullptr) return; @@ -354,7 +367,6 @@ void MDP3Listener::onBookUpdate(onixs::Handler&, const onixs::Security& sec, con for (size_t x = asks_size; x < COCONUT_MAX_DEPTH; ++x) { cache.asks[x] = PriceSize::NO_MARKET; } - // tracepoint (bts_trace,quoter,(char*) "onConsolidatedBookEnd", sec.id(), _latest_sequence); } // // Trades @@ -367,6 +379,7 @@ void on_trade(SecurityData* data, const onixs::PRICE& price, int size, const oni } void MDP3Listener::onTrade(onixs::Handler&, const onixs::Security& sec, const onixs::RecoveryEntryArgs& arg) { + tracepoint (bts_trace,trace_order,(char*) "onTrade.recovery", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != NULL) { int size = 0; @@ -377,6 +390,7 @@ void MDP3Listener::onTrade(onixs::Handler&, const onixs::Security& sec, const on } } void MDP3Listener::onTrade(onixs::Handler&, const onixs::Security& sec, const onixs::TradeSummaryArgs& arg) { + tracepoint (bts_trace,trace_order,(char*) "onTrade.summary", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != NULL) { auto size = arg.entry().entrySize(); @@ -385,6 +399,7 @@ void MDP3Listener::onTrade(onixs::Handler&, const onixs::Security& sec, const on } } void MDP3Listener::onTrade(onixs::Handler&, const onixs::Security& sec, const onixs::TradeArgs& arg) { + tracepoint (bts_trace,trace_order,(char*) "onTrade.trade_args", 0,_latest_sequence); if (arg.entry().updateAction() == onixs::UpdateAction::New) { auto* data = _index.get_security(sec.id()); if (data != nullptr) { @@ -398,6 +413,7 @@ void MDP3Listener::onTrade(onixs::Handler&, const onixs::Security& sec, const on // // RFQ void MDP3Listener::onQuoteRequest(onixs::Handler&, const onixs::Security& sec, const onixs::QuoteRequestRelatedSymArgs& arg) { + tracepoint (bts_trace,trace_order,(char*) "onQuoteRequest", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { auto ts = utils::TimeStamp::now(); @@ -446,6 +462,7 @@ void MDP3Listener::onQuoteRequest(onixs::Handler&, const onixs::Security& sec, c // // Volume void MDP3Listener::onElectronicVolume(onixs::Handler&, const onixs::Security& sec, const onixs::VolumeArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onElectronicVolume.volume", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { bts_assert_d( args.entry().entryType().value() == 'e'); @@ -455,6 +472,7 @@ void MDP3Listener::onElectronicVolume(onixs::Handler&, const onixs::Security& se } } void MDP3Listener::onElectronicVolume(onixs::Handler&, const onixs::Security& sec, const onixs::RecoveryEntryArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onElectronicVolume.recovery", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data) { int32_t size; @@ -467,6 +485,7 @@ void MDP3Listener::onElectronicVolume(onixs::Handler&, const onixs::Security& se // // Misc void MDP3Listener::onSettlementPrice(onixs::Handler&, const onixs::Security& sec, const onixs::DailyStatisticsArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onSettlementPrice.daily", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { onixs::PRICE price; @@ -481,6 +500,7 @@ void MDP3Listener::onSettlementPrice(onixs::Handler&, const onixs::Security& sec } } void MDP3Listener::onSettlementPrice(onixs::Handler&, const onixs::Security& sec, const onixs::RecoveryEntryArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onSettlementPrice.recovery", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { onixs::PRICE price; @@ -495,6 +515,7 @@ void MDP3Listener::onSettlementPrice(onixs::Handler&, const onixs::Security& sec } } void MDP3Listener::onOpenInterest(onixs::Handler&, const onixs::Security& sec, const onixs::DailyStatisticsArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onOpenInterest.daily", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { onixs::PRICE price; @@ -504,6 +525,7 @@ void MDP3Listener::onOpenInterest(onixs::Handler&, const onixs::Security& sec, c } } void MDP3Listener::onOpenInterest(onixs::Handler&, const onixs::Security& sec, const onixs::RecoveryEntryArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onOpenInterest.recovery", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { onixs::PRICE price; @@ -513,6 +535,7 @@ void MDP3Listener::onOpenInterest(onixs::Handler&, const onixs::Security& sec, c } } void MDP3Listener::onOpeningPrice(onixs::Handler&, const onixs::Security& sec, const onixs::SessionStatisticsArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onOpeningPrice.session", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { onixs::PRICE price = args.entry().entryPx(); @@ -525,6 +548,7 @@ void MDP3Listener::onOpeningPrice(onixs::Handler&, const onixs::Security& sec, c } } void MDP3Listener::onOpeningPrice(onixs::Handler&, const onixs::Security& sec, const onixs::RecoveryEntryArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onOpeningPrice.recovery", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { onixs::PRICE price; @@ -539,6 +563,7 @@ void MDP3Listener::onOpeningPrice(onixs::Handler&, const onixs::Security& sec, c } } void MDP3Listener::onHighTradePrice(onixs::Handler&, const onixs::Security& sec, const onixs::SessionStatisticsArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onHighTradePrice.session", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { auto display_factor = data->handle.security().display_factor; @@ -548,6 +573,7 @@ void MDP3Listener::onHighTradePrice(onixs::Handler&, const onixs::Security& sec, } } void MDP3Listener::onHighTradePrice(onixs::Handler&, const onixs::Security& sec, const onixs::RecoveryEntryArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onHighTradePrice.recovery", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { auto display_factor = data->handle.security().display_factor; @@ -559,6 +585,7 @@ void MDP3Listener::onHighTradePrice(onixs::Handler&, const onixs::Security& sec, } } void MDP3Listener::onLowTradePrice(onixs::Handler&, const onixs::Security& sec, const onixs::SessionStatisticsArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onLowTradePrice.session", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { auto display_factor = data->handle.security().display_factor; @@ -568,6 +595,7 @@ void MDP3Listener::onLowTradePrice(onixs::Handler&, const onixs::Security& sec, } } void MDP3Listener::onLowTradePrice(onixs::Handler&, const onixs::Security& sec, const onixs::RecoveryEntryArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onLowTradePrice.recovery", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { auto display_factor = data->handle.security().display_factor; @@ -579,6 +607,7 @@ void MDP3Listener::onLowTradePrice(onixs::Handler&, const onixs::Security& sec, } } void MDP3Listener::onHighestBid(onixs::Handler&, const onixs::Security& sec, const onixs::SessionStatisticsArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onHighestBid.session", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { auto display_factor = data->handle.security().display_factor; @@ -588,6 +617,7 @@ void MDP3Listener::onHighestBid(onixs::Handler&, const onixs::Security& sec, con } } void MDP3Listener::onLowestOffer(onixs::Handler&, const onixs::Security& sec, const onixs::SessionStatisticsArgs& args) { + tracepoint (bts_trace,trace_order,(char*) "onLowestOffer.session", 0,_latest_sequence); auto* data = _index.get_security(sec.id()); if (data != nullptr) { auto display_factor = data->handle.security().display_factor; From 292e5575d0458b6fe10d99bfb90e4798b72f3d33 Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Wed, 6 Jun 2018 15:47:44 -0400 Subject: [PATCH 59/68] Made sim not look for secure logon file. --- src/lib/config/defaults/jetfix.conf | 1 + src/server/sparkd/CMakeDeps.cmake | 2 +- src/web/CMakeDeps.cmake | 2 +- 3 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/lib/config/defaults/jetfix.conf b/src/lib/config/defaults/jetfix.conf index 787f10986..c2e8ab20c 100644 --- a/src/lib/config/defaults/jetfix.conf +++ b/src/lib/config/defaults/jetfix.conf @@ -254,6 +254,7 @@ JetFIX { end_time: "07:48:00" start_time: "07:52:00" raw_data: "1JE9X" + use_cme_secure_logon: false seconds_to_pause : 1 } } diff --git a/src/server/sparkd/CMakeDeps.cmake b/src/server/sparkd/CMakeDeps.cmake index 2039395bc..93a11ab4a 100644 --- a/src/server/sparkd/CMakeDeps.cmake +++ b/src/server/sparkd/CMakeDeps.cmake @@ -1 +1 @@ -set(sources cmds/AutoCert.cpp;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/QuickTest.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Span.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;dspark/mirage.cpp;dspark/mirage/routing/Router.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/book/Book.cpp;exchange_sim/book/ExchangeSim.proto;exchange_sim/book/Order.cpp;exchange_sim/book/OrderMatcher.cpp;exchange_sim/book/book_transform.cpp;exchange_sim/tests/test_book_transform.cpp;http/ApiGateway.cpp;http/WebServer.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/sample_fix.cpp;jetfix/tests/store_tests.cpp;main.cpp;md/platforms/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/MDP3Utils.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;mercury/actors/Actor.cpp;mercury/broker/AsyncEventBroker.cpp;mercury/broker/CoreEventBroker.cpp;mercury/broker/IEventBroker.cpp;mercury/events/TimerEvent.cpp;mercury/mercury_utils/Executor.cpp;mercury/mercury_utils/IPollableActor.cpp;mercury/mercury_utils/mercury_common.cpp;mercury/synopsis/SynopsisBuilder.cpp;mercury/topics/ITopic.cpp;orderman/actors/AsyncFactory.cpp;orderman/actors/ExecutionGateway.cpp;orderman/actors/FillStore.cpp;orderman/actors/OrderStore.cpp;orderman/actors/SecuritySrc.cpp;orderman/actors/ServiceBridge.cpp;orderman/actors/order_manager/OrderBuilder.cpp;orderman/actors/order_manager/OrderManager.cpp;orderman/actors/order_manager/OrderServicesData.cpp;orderman/events/CancelRejectEvent.cpp;orderman/events/NewExecutionReportEvent.cpp;orderman/limiter/LimitStore.cpp;orderman/limiter/Limiter.cpp;orderman/limiter/ProductLimitNode.cpp;orderman/limiter/ProductLimitTree.cpp;orderman/limiter/SecurityLimitNode.cpp;orderman/limiter/SecurityLimitTree.cpp;orderman/limiter/tests/limit_tests.cpp;orderman/order_factory/OrderFactory.cpp;orderman/order_router/OrderRouter.cpp;orderman/orderman_utils/fix_order_codec.cpp;orderman/orders/IcebergOrder.cpp;orderman/orders/NativeOrder.cpp;orderman/orders/Order.cpp;orderman/orders/TimeBoxOrder.cpp;orderman/orders/spreader_orders/SpreaderOrder.cpp;orderman/orders/spreader_orders/spreader/LegPropertyData.cpp;orderman/orders/spreader_orders/spreader/QuoteLegPriceQuantityState.cpp;orderman/orders/spreader_orders/spreader/SingleFillHedger.cpp;orderman/orders/spreader_orders/spreader/SingleLegQuoter.cpp;orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.cpp;orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.cpp;orderman/orders/spreader_orders/spreader/SpreaderLegData.cpp;orderman/orders/spreader_orders/spreader/SpreaderUtils.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderServices.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderPreActivationOrderServices.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterEndStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForCancelAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/orders/spreader_orders/tests/spreader_tests.cpp;orderman/server/OrderServiceServer.cpp;orderman/tests/fat_wrapper_tests.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;position/IMarginObserver.cpp;position/IPositionObserver.cpp;position/MarginServiceCore.cpp;position/PositionServiceCore.cpp;position/tests/PositionTests.cpp;support/ErrorReportService.cpp;testing/catch_test_runner.cpp;tracing/bts_trace_c.c;user/AdminServiceServer.cpp;user/UserServiceServer.cpp;user/tests/admin_service_tests.cpp) \ No newline at end of file +set(sources cmds/AutoCert.cpp;cmds/Benchmark.cpp;cmds/CmdRegistry.cpp;cmds/ConfigCheck.cpp;cmds/Help.cpp;cmds/Md.cpp;cmds/QuickTest.cpp;cmds/Run.cpp;cmds/RunSim.cpp;cmds/Span.cpp;cmds/Test.cpp;cmds/TestCeloxica.cpp;dspark/mirage.cpp;dspark/mirage/routing/Router.cpp;exchange_sim/ExchangeSim.cpp;exchange_sim/ExchangeSimApplication.cpp;exchange_sim/book/Book.cpp;exchange_sim/book/ExchangeSim.proto;exchange_sim/book/Order.cpp;exchange_sim/book/OrderMatcher.cpp;exchange_sim/book/book_transform.cpp;exchange_sim/tests/test_book_transform.cpp;http/ApiGateway.cpp;http/WebServer.cpp;jetfix/codec/FIXArray.cpp;jetfix/common/OutFIX.cpp;jetfix/connection/AsyncReader.cpp;jetfix/connection/IConnection.cpp;jetfix/connection/SocketConnection.cpp;jetfix/gateway/CoreGateway.cpp;jetfix/gateway/JetFIXGateway.cpp;jetfix/gateway/Session.cpp;jetfix/store/FIXFileStore.cpp;jetfix/store/session_name.cpp;jetfix/tests/async_reader_tests.cpp;jetfix/tests/decoding_tests.cpp;jetfix/tests/fix_encoding_stream_tests.cpp;jetfix/tests/fix_fragment_tests.cpp;jetfix/tests/jetfix_performance_tests.cpp;jetfix/tests/sample_fix.cpp;jetfix/tests/store_tests.cpp;main.cpp;md/platforms/celoxica/CXListener.cpp;md/platforms/celoxica/CXMain.cpp;md/platforms/celoxica/tests/cx_tests.cpp;md/platforms/mdp3_onixs/MDP3Listener.cpp;md/platforms/mdp3_onixs/MDP3Main.cpp;md/platforms/mdp3_onixs/MDP3Utils.cpp;md/platforms/mdp3_onixs/tests/mdp3_tests.cpp;md/run_md.cpp;mercury/actors/Actor.cpp;mercury/broker/AsyncEventBroker.cpp;mercury/broker/CoreEventBroker.cpp;mercury/broker/IEventBroker.cpp;mercury/events/TimerEvent.cpp;mercury/mercury_utils/Executor.cpp;mercury/mercury_utils/IPollableActor.cpp;mercury/mercury_utils/mercury_common.cpp;mercury/synopsis/SynopsisBuilder.cpp;mercury/topics/ITopic.cpp;orderman/actors/AsyncFactory.cpp;orderman/actors/ExecutionGateway.cpp;orderman/actors/FillStore.cpp;orderman/actors/OrderStore.cpp;orderman/actors/SecuritySrc.cpp;orderman/actors/ServiceBridge.cpp;orderman/actors/order_manager/OrderBuilder.cpp;orderman/actors/order_manager/OrderManager.cpp;orderman/actors/order_manager/OrderServicesData.cpp;orderman/events/CancelRejectEvent.cpp;orderman/events/NewExecutionReportEvent.cpp;orderman/limiter/LimitStore.cpp;orderman/limiter/Limiter.cpp;orderman/limiter/ProductLimitNode.cpp;orderman/limiter/ProductLimitTree.cpp;orderman/limiter/SecurityLimitNode.cpp;orderman/limiter/SecurityLimitTree.cpp;orderman/limiter/tests/limit_tests.cpp;orderman/order_factory/OrderFactory.cpp;orderman/order_router/OrderRouter.cpp;orderman/orderman_utils/fix_order_codec.cpp;orderman/orders/IcebergOrder.cpp;orderman/orders/NativeOrder.cpp;orderman/orders/Order.cpp;orderman/orders/TimeBoxOrder.cpp;orderman/orders/book_algos/BookAlgo.cpp;orderman/orders/book_algos/JoinOrder.cpp;orderman/orders/book_algos/LeanOrder.cpp;orderman/orders/book_algos/TickOrder.cpp;orderman/orders/book_algos/TopOrder.cpp;orderman/orders/spreader_orders/SpreaderOrder.cpp;orderman/orders/spreader_orders/spreader/LegPropertyData.cpp;orderman/orders/spreader_orders/spreader/QuoteLegPriceQuantityState.cpp;orderman/orders/spreader_orders/spreader/SingleFillHedger.cpp;orderman/orders/spreader_orders/spreader/SingleLegQuoter.cpp;orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.cpp;orderman/orders/spreader_orders/spreader/SpreaderChildOrderState.cpp;orderman/orders/spreader_orders/spreader/SpreaderLegData.cpp;orderman/orders/spreader_orders/spreader/SpreaderUtils.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderBuilder.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderOrderServices.cpp;orderman/orders/spreader_orders/spreader/external_interfacing/SpreaderPreActivationOrderServices.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerEndStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerStartStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForCancelAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForFirstAckCancelledStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWaitingForFirstAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/hedger/hedger_states/HedgerWorkingStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterEndStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterStartStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForCancelAckStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForFirstAckCancelledWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForFirstAckWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWaitingForSizeStateWorker.cpp;orderman/orders/spreader_orders/spreader/quoter/quoter_states/QuoterWorkingStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderEndStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderStartStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderWaitingForCancelAllStateWorker.cpp;orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp;orderman/orders/spreader_orders/tests/spreader_tests.cpp;orderman/server/OrderServiceServer.cpp;orderman/tests/fat_wrapper_tests.cpp;persistence/IStore.cpp;persistence/PersistenceServiceServer.cpp;persistence/SqliteStore.cpp;persistence/tests/PersistenceServiceTests.cpp;position/IMarginObserver.cpp;position/IPositionObserver.cpp;position/MarginServiceCore.cpp;position/PositionServiceCore.cpp;position/tests/PositionTests.cpp;support/ErrorReportService.cpp;testing/catch_test_runner.cpp;tracing/bts_trace_c.c;user/AdminServiceServer.cpp;user/UserServiceServer.cpp;user/tests/admin_service_tests.cpp) \ No newline at end of file diff --git a/src/web/CMakeDeps.cmake b/src/web/CMakeDeps.cmake index e9b642d3a..189373b69 100644 --- a/src/web/CMakeDeps.cmake +++ b/src/web/CMakeDeps.cmake @@ -1 +1 @@ -set(sources ../../externals/linux/include/google/protobuf/descriptor.proto;../../externals/linux/include/google/protobuf/timestamp.proto;../lib/api/apicore.proto;../lib/api/apigateway.proto;../lib/api/apioptions.proto;../lib/api/services/AdminService.proto;../lib/api/services/ApiUnitTestService.proto;../lib/api/services/ErrorReportService.proto;../lib/api/services/HelloService.proto;../lib/api/services/MarketDataRelay.proto;../lib/api/services/OrderService.proto;../lib/api/services/OutOfProcessURLListener.proto;../lib/api/services/PersistenceService.proto;../lib/api/services/ShellDiagnosticService.proto;../lib/api/services/SyntheticSecurityService.proto;../lib/api/services/UserService.proto;../lib/domain_model/Security.proto;../lib/md/protos/co2.proto;../lib/sparkproto/SparkProtos.proto;api/build.sh;api/node_modules/cssstyle/scripts/run_tests.sh;api/node_modules/exit/test/fixtures/create-files.sh;api/node_modules/protobufjs/cli/node_modules/acorn-jsx/node_modules/acorn/bin/update_authors.sh;api/node_modules/watch/release.sh;api/quiet_build.sh;ui/src/Access.fs;ui/src/Accounts/ClipLimits.fs;ui/src/Accounts/ProductLimits.fs;ui/src/Accounts/SecurityLimits.fs;ui/src/Accounts/State.fs;ui/src/Accounts/Types.fs;ui/src/Accounts/View.fs;ui/src/App.fs;ui/src/Cmd.fs;ui/src/Controls/Button.fs;ui/src/Controls/DataGrid.fs;ui/src/Controls/Fields.fs;ui/src/Controls/ReactGrid.fs;ui/src/Controls/Table.fs;ui/src/Controls/nbsp.fs;ui/src/Global.fs;ui/src/Imports.fs;ui/src/Lens.fs;ui/src/Login/Login.fs;ui/src/Navbar/View.fs;ui/src/State.fs;ui/src/Types.fs;ui/src/Users/State.fs;ui/src/Users/Types.fs;ui/src/Users/View.fs;ui/src/Util/EnumUtils.fs;ui/src/Util/JSMap.fs) \ No newline at end of file +set(sources ../../externals/linux/include/google/protobuf/descriptor.proto;../../externals/linux/include/google/protobuf/timestamp.proto;../lib/api/apicore.proto;../lib/api/apigateway.proto;../lib/api/apioptions.proto;../lib/api/services/AdminService.proto;../lib/api/services/ApiUnitTestService.proto;../lib/api/services/ErrorReportService.proto;../lib/api/services/HelloService.proto;../lib/api/services/MarketDataRelay.proto;../lib/api/services/OrderService.proto;../lib/api/services/OutOfProcessURLListener.proto;../lib/api/services/PersistenceService.proto;../lib/api/services/ShellDiagnosticService.proto;../lib/api/services/SyntheticSecurityService.proto;../lib/api/services/UserService.proto;../lib/domain_model/Security.proto;../lib/md/protos/co2.proto;../lib/sparkproto/SparkProtos.proto;api/build.sh;api/node_modules/cssstyle/scripts/run_tests.sh;api/node_modules/exit/test/fixtures/create-files.sh;api/node_modules/protobufjs/cli/node_modules/acorn-jsx/node_modules/acorn/bin/update_authors.sh;api/node_modules/watch/release.sh;api/quiet_build.sh;ui/src/Access.fs;ui/src/Accounts/ClipLimits.fs;ui/src/Accounts/ProductLimits.fs;ui/src/Accounts/SecurityLimits.fs;ui/src/Accounts/State.fs;ui/src/Accounts/Types.fs;ui/src/Accounts/View.fs;ui/src/App.fs;ui/src/Cmd.fs;ui/src/Controls/Button.fs;ui/src/Controls/DataGrid.fs;ui/src/Controls/Fields.fs;ui/src/Controls/Modal.fs;ui/src/Controls/ReactGrid.fs;ui/src/Controls/Table.fs;ui/src/Controls/nbsp.fs;ui/src/Global.fs;ui/src/Imports.fs;ui/src/Lens.fs;ui/src/Login/Login.fs;ui/src/Navbar/View.fs;ui/src/State.fs;ui/src/Types.fs;ui/src/Users/State.fs;ui/src/Users/Types.fs;ui/src/Users/View.fs;ui/src/Util/EnumUtils.fs;ui/src/Util/JSMap.fs) \ No newline at end of file From d291e4a022ebda9297db9cc76c3e9f9cc1d7c3c1 Mon Sep 17 00:00:00 2001 From: Michael Harding Date: Wed, 6 Jun 2018 16:13:20 -0400 Subject: [PATCH 60/68] SPARK-1201: Buttons, Transforms, and Stars --- src/web/ui/public/index.html | 2 +- src/web/ui/sass/main.sass | 13 ++++++++++++- src/web/ui/src/Accounts/State.fs | 2 +- src/web/ui/src/Accounts/View.fs | 32 +++++++++++++++---------------- src/web/ui/src/App.fs | 4 ++-- src/web/ui/src/Controls/Button.fs | 22 ++++++++++++++++++++- src/web/ui/src/Users/View.fs | 11 ++++++----- 7 files changed, 59 insertions(+), 27 deletions(-) diff --git a/src/web/ui/public/index.html b/src/web/ui/public/index.html index 5b0ac2727..98f3855f5 100644 --- a/src/web/ui/public/index.html +++ b/src/web/ui/public/index.html @@ -1,7 +1,7 @@ - BTS Spark Admin + BTS Spark AdminUI diff --git a/src/web/ui/sass/main.sass b/src/web/ui/sass/main.sass index 62dca716f..fbb19967a 100644 --- a/src/web/ui/sass/main.sass +++ b/src/web/ui/sass/main.sass @@ -63,4 +63,15 @@ table .fabutton border: 0 th border: 0 - \ No newline at end of file + +.selector-button + width: 100% + margin-top: 1ex + text-align: left + justify-content: left + +.contrast-button + background-color: #ebebeb + border-color: #ccc + &:hover + background-color: #dbdbdb \ No newline at end of file diff --git a/src/web/ui/src/Accounts/State.fs b/src/web/ui/src/Accounts/State.fs index 89e4c93f3..e168fd32d 100644 --- a/src/web/ui/src/Accounts/State.fs +++ b/src/web/ui/src/Accounts/State.fs @@ -21,7 +21,7 @@ let init (context:ServiceContext.ServiceContext) = mdRelayExpNameData = Array.empty scratch = emptyAccount previousScratch = emptyAccount - AllValue = " " + AllValue = "*" AllValueDisplay = "All" }, Access.getAdminData admin UpdateAdminData NoAdminData diff --git a/src/web/ui/src/Accounts/View.fs b/src/web/ui/src/Accounts/View.fs index 228452809..6c6b5ddad 100644 --- a/src/web/ui/src/Accounts/View.fs +++ b/src/web/ui/src/Accounts/View.fs @@ -6,7 +6,6 @@ open Fable.Helpers.React open Fable.Helpers.React.Props open Button open bts.api.admin -open DataGrid open bts.api.orderman open EnumUtils open Fable @@ -34,7 +33,7 @@ let saveButton model dispatch = let enabled = if dirty then Enabled else Disabled let flavor = if dirty then "is-success" else "is-light" Button.button buttonText flavor "" enabled (fun _ -> dispatch SaveScratch) - +(* let mappedDataGridWithAddDelete<'a,'r> title (descriptor:MappedDataGridDescriptor<'a,'r>) props (rows:'a[]) erase (dispatch:'a[]->unit) = let addRow _ = Array.append rows [| descriptor.emptyRow |] |> dispatch // Why can't `erase` have the same signature as dispatch? @@ -50,12 +49,12 @@ let mappedDataGridWithAddDelete<'a,'r> title (descriptor:MappedDataGridDescripto div [ClassName "level-left"] [] div [ClassName "level-right"] [ div [ClassName "level-item"] [ - Button.fabutton "Add Row" "plus" Button.Enabled addRow + Button.addButton Button.Enabled addRow ] ] ] ] - +*) // // General // @@ -155,7 +154,7 @@ let clipLimitsView model dispatch = [ for limit in model.scratch.securityClipLimits.limit do yield { cells = [ - TableControl.Cell (Button.fabutton "Remove" "times" Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.securityClipLimits.limit) |> DeleteClipLimit |> dispatch)) + TableControl.Cell (Button.removeButton Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.securityClipLimits.limit) |> DeleteClipLimit |> dispatch)) TableControl.Cell (Fields.enumSelect "" (EnumUtils.toHuman false venues limit.security.exchange) @@ -204,7 +203,7 @@ let clipLimitsView model dispatch = div [] [ TableControl.createTableWithStyle (Some headerRow) rws [Width "100%"; Border "1px solid lightgray"] - span [ClassName "is-pulled-right"] [ Button.fabutton "Add Row" "plus" Button.Enabled addRow ] + span [ClassName "is-pulled-right"] [ Button.button "Add" "contrast-button" "plus" Button.Enabled addRow ] span [ClassName "is-clearfix"][] ] @@ -258,7 +257,7 @@ let productLimits model dispatch = [ for limit in model.scratch.productPositionLimits do yield { cells = [ - TableControl.Cell (Button.fabutton "Remove" "times" Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.productPositionLimits) |> DeleteProductLimit |> dispatch)) + TableControl.Cell (Button.removeButton Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.productPositionLimits) |> DeleteProductLimit |> dispatch)) TableControl.Cell (Fields.enumSelect "" (EnumUtils.toHuman false venues limit.product.exchange) @@ -313,7 +312,7 @@ let productLimits model dispatch = [ h1 [ ClassName "is-size-4" ][str "Product Limits"]//; span [ClassName "is-size-7 has-text-grey-light"][ str " This is a limit for products"] ] TableControl.createTableWithStyle (Some headerRow) rws [Width "100%"; Border "1px solid lightgray"] - span [ClassName "is-pulled-right"] [ Button.fabutton "Add Row" "plus" Button.Enabled addRow ] + span [ClassName "is-pulled-right"] [ Button.button "Add" "contrast-button" "plus" Button.Enabled addRow ] span [ClassName "is-clearfix"][] ] @@ -391,7 +390,7 @@ let securityLimits model dispatch = [ for limit in model.scratch.securityPositionLimits do yield { cells = [ - TableControl.Cell (Button.fabutton "Remove" "times" Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.securityPositionLimits) |> DeleteSecurityLimit |> dispatch)) + TableControl.Cell (Button.removeButton Button.Enabled (fun _ -> (Array.findIndex (fun l -> limit = l) model.scratch.securityPositionLimits) |> DeleteSecurityLimit |> dispatch)) TableControl.Cell (Fields.enumSelect "" (EnumUtils.toHuman false venues limit.security.exchange) @@ -449,7 +448,7 @@ let securityLimits model dispatch = [ h1 [ ClassName "is-size-4" ][str "Security Limits"]//; span [ClassName "is-size-7 has-text-grey-light"][ str " This is a limit for Securities"]] TableControl.createTableWithStyle (Some headerRow) rws [Width "100%"; Border "1px solid lightgray"] - span [ClassName "is-pulled-right"] [ Button.fabutton "Add Row" "plus" Button.Enabled addRow ] + span [ClassName "is-pulled-right"] [ Button.button "Add" "contrast-button" "plus" Button.Enabled addRow ] span [ClassName "is-clearfix"][] ] @@ -466,7 +465,7 @@ let ConnectionsView (model:Accounts.Types.Model) dispatch = let rws:TableControl.row list = [for name in conNames do yield { cells = [ - (TableControl.Cell (Button.fabutton "" "times" Button.Enabled (fun _ -> name |> ( RemoveConnection >> dispatch)))) + (TableControl.Cell (Button.removeButton Button.Enabled (fun _ -> name |> ( RemoveConnection >> dispatch)))) (TableControl.Cell (str name)) ] className="no-border" @@ -524,13 +523,14 @@ let tabContent model dispatch = let accountControls selected (dispatch:Msg->unit) = let remButton = match selected with - | None -> fabutton "Remove" "times" Disabled ignore - | Some acc -> fabutton "Remove" "times" Enabled (fun _ -> dispatch <| DeleteAccount acc) + | None -> Button.button "Remove" "contrast-button selector-button" "times" Disabled ignore + | Some acc -> Button.button "Remove" "contrast-button selector-button" "times" Enabled (fun _ -> dispatch <| DeleteAccount acc) div [ClassName "is-clearfix plus-margin-top"] [ - p [ ClassName "is-pulled-right" ][ - fabutton "Add" "plus" Enabled (fun _ -> dispatch AddAccount) - nbsp.element + p [ ClassName "" ][ + Button.button "Add" "contrast-button selector-button" "plus" Enabled (fun _ -> dispatch AddAccount) + //nbsp.element + br [] remButton ] ] diff --git a/src/web/ui/src/App.fs b/src/web/ui/src/App.fs index 2313a9490..42d8c5930 100644 --- a/src/web/ui/src/App.fs +++ b/src/web/ui/src/App.fs @@ -72,8 +72,8 @@ let navRoot currentPage sc dispatch = h1 [ ClassName "navbar-item" ] [ - span [] [ str "BTS Spark Admin " ] - span [ Style [ CSSProp.Color "#ddf"; FontSize "60%"; MarginLeft "1em"] ] [ str " (beta)" ] + span [Style [ FontSize "1.5rem";]] [ str "BTS Spark AdminUI" ] + span [ Style [ CSSProp.Color "#fff"; FontSize "0.7rem"; Margin ".5ex 0 0 0"; Transform "rotate(90deg)"] ] [ str "beta" ] ] navItem "Users" "users" (tmap (Users.State.init sc) (UsersModel, Cmd.map UsersMsg)) currentPage dispatch navItem "Accounts" "server" (tmap (Accounts.State.init sc) (AccountsModel,Cmd.map AccountsMsg)) currentPage dispatch diff --git a/src/web/ui/src/Controls/Button.fs b/src/web/ui/src/Controls/Button.fs index 87347da90..605f2fc77 100644 --- a/src/web/ui/src/Controls/Button.fs +++ b/src/web/ui/src/Controls/Button.fs @@ -12,6 +12,26 @@ let isDisabled = function | Disabled -> true | Enabled -> false +let addButton disabled click = + a [ ClassName "button fabutton " + HTMLAttr.Disabled (isDisabled disabled) + Title "Add" + OnClick click ] [ + span [ ClassName "icon is-small has-text-success" ] [ + i [ ClassName "fa fa-plus"] [ ] ] + ] + +let removeButton disabled click = + a [ ClassName "button fabutton" + Style [] + HTMLAttr.Disabled (isDisabled disabled) + Title "Remove" + OnClick click ] [ + span [ ClassName "icon has-text-danger" ] [ + i [ ClassName "fa fa-times"] [ ] ] + ] + + let fabutton title icon disabled click = a [ ClassName "button fabutton" HTMLAttr.Disabled (isDisabled disabled) @@ -34,7 +54,7 @@ let falink title icon disabled click = let button text flavor icon disabled click = a [ ClassName (sprintf "button %s" flavor) HTMLAttr.Disabled (isDisabled disabled) - Title text + //Title text OnClick click] [ (match icon with | "" -> str text diff --git a/src/web/ui/src/Users/View.fs b/src/web/ui/src/Users/View.fs index affa1b735..7d1e638c2 100644 --- a/src/web/ui/src/Users/View.fs +++ b/src/web/ui/src/Users/View.fs @@ -77,7 +77,7 @@ let accountsTabContent (model:Model) (dispatch:Msg->Unit) = let rws:TableControl.row list = [for (key,name) in keys do yield { cells = [ - TableControl.Cell(Button.fabutton "" "times" Button.Enabled (fun _ -> key |> (RemoveAccount >> UpdateField >> dispatch))) + TableControl.Cell(Button.removeButton Button.Enabled (fun _ -> key |> (RemoveAccount >> UpdateField >> dispatch))) TableControl.Cell(str name) TableControl.Cell( str "Full") TableControl.Cell(str "Full") @@ -149,10 +149,11 @@ let tabContent (model:Model) (dispatch:Msg->Unit) = let userControls (usersList:BTSUser list) (currentUser:BTSUser) (dispatch:Msg->Unit) (disabled:bool)= div [ ClassName "is-clearfix plus-margin-top" ] [ - p [ ClassName "is-pulled-right" ][ - Button.fabutton "Add" "plus" Button.Enabled (fun _ -> dispatch <| AddUser) - nbsp.element - Button.fabutton "Remove" "times" Button.Enabled (fun _ -> dispatch <| Delete currentUser) + p [ ClassName "" ][ + Button.button "Add" "contrast-button selector-button" "plus" Button.Enabled (fun _ -> dispatch <| AddUser) + //nbsp.element + br [] + Button.button "Remove" "contrast-button selector-button" "times" Button.Enabled (fun _ -> dispatch <| Delete currentUser) ] (*p [ ClassName "control" ] [ a [ ClassName "button is-light" From f7a3b3ebc1d6798f1cbe6427594a35210ff99716 Mon Sep 17 00:00:00 2001 From: Jake Norbut Date: Wed, 6 Jun 2018 15:49:46 -0500 Subject: [PATCH 61/68] Fixing badge height overlapping level line --- src/client/spark/view/Spark/Ladder/LadderView.xaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/client/spark/view/Spark/Ladder/LadderView.xaml b/src/client/spark/view/Spark/Ladder/LadderView.xaml index c9c0bd8b1..2a1dbb4b5 100644 --- a/src/client/spark/view/Spark/Ladder/LadderView.xaml +++ b/src/client/spark/view/Spark/Ladder/LadderView.xaml @@ -453,7 +453,7 @@ - + From a7b3b0fa6d0ef843b7af72e0871a9aa6d7dee079 Mon Sep 17 00:00:00 2001 From: Eric Harding Date: Wed, 6 Jun 2018 16:55:03 -0400 Subject: [PATCH 62/68] SPARK-1197 MarketSegmentID --- src/lib/domain_model/Security.proto | 1 + src/lib/md/Shm/FixedSecurity.cpp | 9 +++++++-- src/lib/md/Shm/FixedSecurity.h | 6 ++---- 3 files changed, 10 insertions(+), 6 deletions(-) diff --git a/src/lib/domain_model/Security.proto b/src/lib/domain_model/Security.proto index dbc716d47..18f6662ff 100644 --- a/src/lib/domain_model/Security.proto +++ b/src/lib/domain_model/Security.proto @@ -58,6 +58,7 @@ message GLBXExchangeData { uint32 main_fraction = 30; uint32 sub_fraction = 31; uint32 price_display_format = 32; + uint32 market_segment_id = 33; } message CBOEExchangeData { int64 exchange_id = 10; diff --git a/src/lib/md/Shm/FixedSecurity.cpp b/src/lib/md/Shm/FixedSecurity.cpp index 05c95fff4..4221112fe 100644 --- a/src/lib/md/Shm/FixedSecurity.cpp +++ b/src/lib/md/Shm/FixedSecurity.cpp @@ -22,11 +22,14 @@ FixedSecurity::FixedSecurity() : type(api::SECURITYTYPE_STOCK), exchange(api::VENUE_UNSET), display_factor(0), - cboe_class_key(0), - cme_market_segment_id(0), price_break(0), low_tick(0), high_tick(0), + cboe_class_key(0), + cme_market_segment_id(0), + cme_main_fraction(0), + cme_sub_fraction(0), + cme_price_display_format(0), _symbol(), _cfi_code(), _security_desc(), @@ -157,6 +160,7 @@ void convert_security(const FixedSecurity& source, Security* presult) { dest.mutable_glbx()->set_security_desc(source.security_desc()); dest.mutable_glbx()->set_cfi_code(source.cfi_code()); dest.mutable_glbx()->set_cme_symbol(source.alt_symbol()); + if (source.cme_market_segment_id != 0) dest.mutable_glbx()->set_market_segment_id(source.cme_market_segment_id); if (source.cme_main_fraction != 0) dest.mutable_glbx()->set_main_fraction(source.cme_main_fraction); if (source.cme_sub_fraction != 0) dest.mutable_glbx()->set_sub_fraction(source.cme_sub_fraction); if (source.cme_price_display_format) dest.mutable_glbx()->set_price_display_format(source.cme_price_display_format); @@ -257,6 +261,7 @@ void convert_security(const Security& src, FixedSecurity& dest, bool set_securit dest.security_desc(src.glbx().security_desc()); dest.cfi_code(src.glbx().cfi_code()); dest.alt_symbol(src.glbx().cme_symbol()); + dest.cme_market_segment_id = src.glbx().market_segment_id(); dest.cme_main_fraction = src.glbx().main_fraction(); dest.cme_sub_fraction = src.glbx().sub_fraction(); dest.cme_price_display_format = src.glbx().price_display_format(); diff --git a/src/lib/md/Shm/FixedSecurity.h b/src/lib/md/Shm/FixedSecurity.h index 3bf0486ab..b8fd82d55 100644 --- a/src/lib/md/Shm/FixedSecurity.h +++ b/src/lib/md/Shm/FixedSecurity.h @@ -45,15 +45,13 @@ public: int8_t display_factor; - uint32_t cboe_class_key; - - uint32_t cme_market_segment_id; - double price_break; double low_tick; double high_tick; double cash_per_point; + uint32_t cboe_class_key; + uint8_t cme_market_segment_id; uint8_t cme_main_fraction; uint8_t cme_sub_fraction; uint8_t cme_price_display_format; From b07f6aba59260ee9f71ed71050768babfb908730 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Wed, 6 Jun 2018 15:47:56 -0400 Subject: [PATCH 63/68] comments, code style --- .../orders/spreader_orders/SpreaderOrder.cpp | 248 ++++++++---------- .../orders/spreader_orders/SpreaderOrder.h | 104 +++++--- .../SpreaderWorkingStateWorker.cpp | 34 ++- 3 files changed, 196 insertions(+), 190 deletions(-) diff --git a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp index ef396e46c..2ebf837c9 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp @@ -11,93 +11,81 @@ namespace bts { namespace orderman { /**************************Cons/Dest*******************************/ SpreaderOrder::SpreaderOrder() - : - _cancelled (false), - _cancel_timeout (5000),// TODO:get it from config - _active(true), - //_bookkeeping_data_ptr(nullptr), - _order_services(nullptr), - _reported_state(), - _state_worker(nullptr), - _start_state_worker(this), _working_state_worker(this), _waiting_for_cancel_all_state_worker(this), _end_state_worker(this) -{ +: +_cancelled (false), +_cancel_timeout (5000),// TODO:get it from config +_active(true), +_bookkeeping_data_ptr(), +_order_services(nullptr), +_reported_state(), +_state_worker(nullptr), +_start_state_worker(this), _working_state_worker(this), _waiting_for_cancel_all_state_worker(this), _end_state_worker(this){ _transform_to_START(); } SpreaderOrder::~SpreaderOrder () {} -/***********************************************************************/ -/******************************Order Derived****************************/ -/***********************************************************************/ -const api::orderman::OrderDefinition& SpreaderOrder::definition() const -{ +// Order Derived //////////////////// +///////////////////////////////////// +const api::orderman::OrderDefinition& SpreaderOrder::definition() const{ bts_assert(_inited()); return _bookkeeping_data().order_def(); } -void SpreaderOrder::on_init_new(const api::orderman::OrderDefinition& order_def, const PreActivationOrderServices& pao_services) -{ - if (!_active) return; +void SpreaderOrder::on_init_new(const api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices& pao_services){ + if (!_active) return; _on_init_new(order_def, SpreaderPreActivationOrderServices(&pao_services)); _report_state (); } -void SpreaderOrder::on_init_recovered(const bts::api::orderman::OrderRecord& order_record, const bts::orderman::PreActivationOrderServices& pao_services) -{ +void SpreaderOrder::on_init_recovered(const bts::api::orderman::OrderRecord& order_record, + const PreActivationOrderServices& pao_services){ LOG(OrderMan, Info, "SpreaderOrder.on_init_recovered order_key: {}", key().value()); _state_worker->on_init_recovered(order_record, SpreaderPreActivationOrderServices(&pao_services)); _report_state(); } -void SpreaderOrder::on_activate(Price price, Quantity quantity, OrderServices& services) -{ - if (!_active) return; +void SpreaderOrder::on_activate(Price price, Quantity quantity, + OrderServices& services){ + if (!_active) return; SpreaderOrderServices spreader_order_services (&services); _on_activate(price, quantity, spreader_order_services); _report_state(); } -void SpreaderOrder::on_update(Price price, Quantity quantity) -{ +void SpreaderOrder::on_update(Price price, Quantity quantity){ if (!_active) return; LOG(OrderMan, Info, "SpreaderOrder.on_update key: {} price: {} quantity: {}", key().value(), price.value(), quantity.value()); _state_worker->on_update(price, quantity); _report_state(); } -void SpreaderOrder::on_cancel() -{ +void SpreaderOrder::on_cancel(){ if (!_active) return; LOG(OrderMan, Info, "SpreaderOrder.on_cancel key: {}", key().value()); _state_worker->on_cancel(); _report_state(); } -void SpreaderOrder::on_crack() -{ +void SpreaderOrder::on_crack(){ if (!_active) return; LOG(OrderMan, Info, "SpreaderOrder.on_crack key: {}", key().value()); _state_worker->on_crack(); _report_state(); } -/***********************************************************************/ -/****************************ISpreaderManager***************************/ -/***********************************************************************/ -void SpreaderOrder::setup_new_quoter_order(size_t leg_index) -{ +// ISpreaderManager //////////////////// +//////////////////////////////////////// +void SpreaderOrder::setup_new_quoter_order(size_t leg_index){ LOG(OrderMan, Info, "SpreaderOrder.setup_new_quoter_order key: {} leg: {}", key().value(), leg_index); SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(leg_index); bts::orderman::ChildOrder child_order = leg_data.quoter_order_builder().build(); leg_data.order_update_message().re_init(child_order); } -/***********************************************************************/ -/******************************Event Handlers***************************/ -/***********************************************************************/ -void SpreaderOrder::_on_time(const bts::mercury::TimerEvent& t_event) -{ +// events from orders system //////////////////// + ///////////////////////////////////////////////// +void SpreaderOrder::_on_time(const bts::mercury::TimerEvent& t_event){ _curr_timestamp = t_event.ts; if (!_active) return; _state_worker->on_time (_curr_timestamp); } -void SpreaderOrder::_on_book_update(const bts::orderman::BookUpdateEvent& book_event) -{ +void SpreaderOrder::_on_book_update(const BookUpdateEvent& book_event){ if (!_active) return; _state_worker->on_book (book_event.correlation_id, book_event.book); } -void SpreaderOrder::_on_child_order_update(const bts::orderman::OrderStateUpdateEvent& ord_ev) -{ +void SpreaderOrder::_on_child_order_update(const OrderStateUpdateEvent& ord_ev){ if (!_active) return; SecurityKey sec_key = SecurityKey(ord_ev.definition->security_key()); OrderKey order_key = ord_ev.key; @@ -105,21 +93,19 @@ void SpreaderOrder::_on_child_order_update(const bts::orderman::OrderStateUpdate Quantity filled_qty = Quantity (ord_ev.state.filled_quantity()); Price last_price = Price(ord_ev.state.last_price()); LOG(OrderMan, Diag, "SpreaderOrder::_on_child_order_update key: {} sec_key: {} order_key: {} status: {} filled_qty: {} last_price: {} msg: {}", key(), sec_key, order_key, status, filled_qty, last_price, ord_ev.state.last_msg ()); - if (!SpreaderUtils::order_acknowledged(status)) - { + if (!SpreaderUtils::order_acknowledged(status)){ LOG(OrderMan, Diag, "SpreaderOrder::_on_child_order_update, unack'ed callback for key: {} sec_key: {} order_key: {} status: {} ignoring", key(), sec_key, order_key, status); bts_assert(filled_qty.value() == 0); return; } SpreaderLegData* leg_data_ptr = _bookkeeping_data().find_leg_from_quoter_orderkey(order_key); // can also be found through sec_key - if (leg_data_ptr != nullptr) - { + if (leg_data_ptr != nullptr){ SpreaderLegData& leg_data = *leg_data_ptr; ChildOrderError order_error = _get_order_error (ord_ev, leg_data.quoter().expecting_cancel_update()); - LOG(OrderMan, Info, "SpreaderOrder::_on_child_order_update quoter order key: {} sec_key: {} order_key: {} status: {} filled_qty: {} last_price: {} msg: {} child_order_error: {}", key(), sec_key, order_key, status, filled_qty, last_price, ord_ev.state.last_msg (), static_cast(order_error)); + LOG(OrderMan, Info, "SpreaderOrder::_on_child_order_update quoter order key: {} sec_key: {} order_key: {} status: {} filled_qty: {} last_price: {} msg: {} child_order_error: {}", + key(), sec_key, order_key, status, filled_qty, last_price, ord_ev.state.last_msg (), static_cast(order_error)); leg_data.order_update_message().on_order_update(ord_ev); - if (order_error == ChildOrderError::NONE) - { + if (order_error == ChildOrderError::NONE){ if (leg_data.order_update_message().last_update_filled_quantity().value() > 0) _state_worker->on_quoter_order_fill (leg_data); else @@ -128,98 +114,87 @@ void SpreaderOrder::_on_child_order_update(const bts::orderman::OrderStateUpdate else _state_worker->on_quoter_order_error (leg_data); } - else - { + else{ // should be a hedge order then SingleFillHedger* hedger = _bookkeeping_data().find_hedger_from_orderkey(order_key); - if (hedger != nullptr) - { - ChildOrderError order_error = _get_order_error (ord_ev, hedger->expecting_cancel_update()); - LOG(OrderMan, Info, "SpreaderOrder::_on_child_order_update hedger order: key: {} sec_key: {} order_key: {} status: {} filled_qty: {} last_price: {} msg: {} child_order_error: {}", key(), sec_key, order_key, status, filled_qty, last_price, ord_ev.state.last_msg (), static_cast(order_error)); + if (hedger != nullptr){ + ChildOrderError order_error = _get_order_error (ord_ev, hedger->expecting_cancel_update()); + LOG(OrderMan, Info, "SpreaderOrder::_on_child_order_update hedger order: key: {} sec_key: {} order_key: {} status: {} filled_qty: {} last_price: {} msg: {} child_order_error: {}", + key(), sec_key, order_key, status, filled_qty, last_price, ord_ev.state.last_msg (), static_cast(order_error)); hedger->order_state().on_order_update(ord_ev); if (order_error == ChildOrderError::NONE) - _state_worker->on_hedger_order_update (*hedger); + _state_worker->on_hedger_order_update (*hedger); else _state_worker->on_hedger_order_error (*hedger); } else - { - LOG(OrderMan, Error, "SpreaderOrder::_on_child_order_update unknown order key: {} sec_key: {} order_key: {} status: {} filled_qty: {} last_price: {} msg: {}", key(), sec_key, order_key, status, filled_qty, last_price, ord_ev.state.last_msg ()); - } + LOG(OrderMan, Error, "SpreaderOrder::_on_child_order_update unknown order key: {} sec_key: {} order_key: {} status: {} filled_qty: {} last_price: {} msg: {}", + key(), sec_key, order_key, status, filled_qty, last_price, ord_ev.state.last_msg ()); } _state_worker->on_check_termination (); _report_state(); } -/***********************************************************************/ -/*************************State Transformations*************************/ -/***********************************************************************/ -void SpreaderOrder::_transform_to_START() -{ +// State Transformations //////////////////// +///////////////////////////////////////////// +void SpreaderOrder::_transform_to_START(){ bts_assert (_state_worker == nullptr); _switch_state (&_start_state_worker); } -void SpreaderOrder::_transform_to_WORKING() -{ +void SpreaderOrder::_transform_to_WORKING(){ bts_assert(_state_worker->state() == SpreaderState::START); _switch_state(&_working_state_worker); } -void SpreaderOrder::_transform_to_WAITING_FOR_CANCEL_ALL() -{ +void SpreaderOrder::_transform_to_WAITING_FOR_CANCEL_ALL(){ bts_assert(_state_worker->state() == SpreaderState::WORKING); _switch_state(&_waiting_for_cancel_all_state_worker); } -void SpreaderOrder::_transform_to_END(std::string*) -{ +void SpreaderOrder::_transform_to_END(std::string*){ bts_assert(_state_worker->state() != SpreaderState::END); _switch_state(&_end_state_worker); } -void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state) -{ - LOG(OrderMan, Info, "SpreaderOrder::_switch_state key: {}, {} -> {} ", key().value(), (_state_worker == nullptr ? -1 : (int)_state_worker->state()), (int)new_state->state()); +void SpreaderOrder::_switch_state (ISpreaderStateWorker* new_state){ + LOG(OrderMan, Info, "SpreaderOrder::_switch_state key: {}, {} -> {} ", + key().value(), + (_state_worker == nullptr ? -1 : (int)_state_worker->state()), + (int)new_state->state()); _state_worker = new_state; _state_worker->on_transition(); _report_state(); } -/***********************************************************************/ -/*********************************Misc**********************************/ -/***********************************************************************/ -void SpreaderOrder::_on_init_new(const bts::api::orderman::OrderDefinition& order_def, const SpreaderPreActivationOrderServices& spreader_pao_services) -{ - LOG(OrderMan, Info, "SpreaderOrder.on_init_new key: {} order_def: {}", key().value(), bts::utils::pb::to_string(order_def)); + +void SpreaderOrder::_on_init_new(const bts::api::orderman::OrderDefinition& order_def, + const SpreaderPreActivationOrderServices& spreader_pao_services){ + LOG(OrderMan, Info, "SpreaderOrder.on_init_new key: {} order_def: {}", + key().value(), bts::utils::pb::to_string(order_def)); bts_assert(!_inited()); _state_worker->on_init_new(order_def, spreader_pao_services); } -void SpreaderOrder::_on_activate(Price price, Quantity quantity, SpreaderOrderServices& order_services) -{ +void SpreaderOrder::_on_activate(Price price, Quantity quantity, SpreaderOrderServices& order_services){ bts_assert(_inited()); bts_assert(!_activated()); - LOG(OrderMan, Info, "SpreaderOrder.on_activate key: {} price: {} quantity: {}", key().value(), price.value(), quantity.value()); + LOG(OrderMan, Info, "SpreaderOrder.on_activate key: {} price: {} quantity: {}", + key().value(), price.value(), quantity.value()); _order_services = new SpreaderOrderServices(order_services); _state_worker->on_activate(price, quantity, *_order_services); } -void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges) -{ - LOG(OrderMan, Info, "SpreaderOrder::_cancel_orders key: {}, cancel_quotes: {} cancel_hedges: {}", key().value(), cancel_quotes, cancel_hedges); - for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++) - { +void SpreaderOrder::_cancel_orders(bool cancel_quotes, bool cancel_hedges){ + LOG(OrderMan, Info, "SpreaderOrder::_cancel_orders key: {}, cancel_quotes: {} cancel_hedges: {}", + key().value(), cancel_quotes, cancel_hedges); + for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx); - if (cancel_quotes) - { + if (cancel_quotes){ if (leg_data.leg_property_data().is_active_quoting()) leg_data.quoter().cancel_order(); } if (cancel_hedges) - for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) - { + for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++){ SingleFillHedger& hedger = leg_data.get_hedger(h_idx); hedger.cancel_hedge(); } } } -bool SpreaderOrder::_all_quoter_orders_in_terminal_state() -{ - for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++) - { +bool SpreaderOrder::_all_quoter_orders_in_terminal_state(){ + for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) if (!leg_data.quoter().is_terminal_state()) @@ -227,14 +202,10 @@ bool SpreaderOrder::_all_quoter_orders_in_terminal_state() } return true; } -// same as _all_quoter_orders_in_terminal_state, for hedgers -bool SpreaderOrder::_all_hedger_orders_in_terminal_state() -{ - for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++) - { +bool SpreaderOrder::_all_hedger_orders_in_terminal_state(){ + for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx); - for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) - { + for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++){ SingleFillHedger& hedger = leg_data.get_hedger(h_idx); if (!hedger.is_terminal_state()) return false; @@ -242,30 +213,23 @@ bool SpreaderOrder::_all_hedger_orders_in_terminal_state() } return true; } -void SpreaderOrder::_terminate_quoters () -{ - for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++) - { +void SpreaderOrder::_terminate_quoters (){ + for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx); - leg_data.quoter().terminate(); + leg_data.quoter().terminate(); } } -void SpreaderOrder::_terminate_hedgers () -{ - for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++) - { +void SpreaderOrder::_terminate_hedgers (){ + for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx); - for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++) - { + for (size_t h_idx = 0; h_idx < leg_data.n_hedgers(); h_idx++){ SingleFillHedger& hedger = leg_data.get_hedger(h_idx); hedger.terminate (); } } } -bool SpreaderOrder::_quoters_can_accept_modification () -{ - for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++) - { +bool SpreaderOrder::_quoters_can_accept_modification (){ + for (size_t q_idx = 0; q_idx < _bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& leg_data = _bookkeeping_data().get_leg_data(q_idx); if (leg_data.leg_property_data().is_active_quoting()) if (!leg_data.quoter().accept_modifications()) @@ -273,46 +237,48 @@ bool SpreaderOrder::_quoters_can_accept_modification () } return true; } -void SpreaderOrder::_send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, - size_t hedge_leg_index) -{ +void SpreaderOrder::_send_hedge(size_t filled_leg_index, + Price filled_price, + Quantity filled_quantity, + size_t hedge_leg_index){ LOG(OrderMan, Info, "SpreaderOrder::_send_hedge key: {}, filled_leg_index: {} filled_price: {} filled_quantity: {} hedge_leg_index: {}", key().value(), filled_leg_index, filled_price.value(), filled_quantity.value(), hedge_leg_index); Price hedge_price; Quantity hedge_quantity; - _compute_hedge_price_quantity (filled_leg_index, filled_price, filled_quantity, hedge_leg_index, + _compute_hedge_price_quantity (filled_leg_index, filled_price, + filled_quantity, hedge_leg_index, hedge_price, hedge_quantity); - SingleFillHedger& hedger = _bookkeeping_data().add_new_hedger (*this, hedge_leg_index, hedge_price, hedge_quantity); + SingleFillHedger& hedger = _bookkeeping_data().add_new_hedger (*this, + hedge_leg_index, + hedge_price, + hedge_quantity); hedger.init (); } void SpreaderOrder::_compute_hedge_price_quantity(size_t filled_leg_index, Price fill_price, Quantity fill_quantity, size_t hedge_leg_index, - Price& hedge_price, Quantity& hedge_quantity) -{ + Price& hedge_price, Quantity& hedge_quantity){ Price computed_hedge_price; SpreaderLegData& filled_leg_data = _bookkeeping_data().get_leg_data(filled_leg_index); SpreaderLegData& hedged_leg_data = _bookkeeping_data().get_leg_data(hedge_leg_index); if (_bookkeeping_data().n_legs() == 2) - { SpreaderUtils::compute_hedge_price_size_2_legs (_bookkeeping_data().price(), filled_leg_data.leg_property_data(), fill_price, fill_quantity, hedged_leg_data.leg_property_data(), computed_hedge_price, hedge_quantity); - } - else - { + else{ const QuoterLegDriverData& driver_data = filled_leg_data.quoter().driver_data(hedge_leg_index); SpreaderUtils::compute_hedge_price_size_n_legs (filled_leg_data.leg_property_data(), fill_price, fill_quantity, hedged_leg_data.leg_property_data(), driver_data, computed_hedge_price, hedge_quantity); } - hedge_price = SpreaderUtils::apply_pre_hedge_parameters (hedged_leg_data.leg_property_data().leg_params().pre_hedge_params(), hedged_leg_data.book(), hedged_leg_data.leg_property_data().trading_side(), hedged_leg_data.leg_property_data().tick_size(), + hedge_price = SpreaderUtils::apply_pre_hedge_parameters (hedged_leg_data.leg_property_data().leg_params().pre_hedge_params(), + hedged_leg_data.book(), + hedged_leg_data.leg_property_data().trading_side(), + hedged_leg_data.leg_property_data().tick_size(), computed_hedge_price, hedge_quantity); } -void SpreaderOrder::_report_state () -{ - if (_activated()) - { +void SpreaderOrder::_report_state (){ + if (_activated()){ SpreaderBookkeepingData& bookkeeping_data = _bookkeeping_data(); api::orderman::OrderStatus status = _get_order_status (); Quantity filled_qty; Price avg_filled_price; @@ -322,17 +288,15 @@ void SpreaderOrder::_report_state () _reported_state.set_quantity(bookkeeping_data.quantity().value()); _reported_state.set_filled_quantity(filled_qty.value()); _reported_state.set_avg_price(avg_filled_price.value()); - // TODO fill in filled_qty etc + // TODO fill in filled_qty etc LOG(OrderMan, Info, "SpreaderOrder::_report_state key: {} status: {} price: {} qty: {} filled: {} abg_price: {}", key(), status, _reported_state.price(), _reported_state.quantity(), _reported_state.filled_quantity(), _reported_state.avg_price()); _order_services->report_state(_reported_state); } } -bts::api::orderman::OrderStatus SpreaderOrder::_get_order_status () const -{ - SpreaderState curr_state = _state_worker == nullptr ? SpreaderState::START : _state_worker->state(); - switch (curr_state) - { +bts::api::orderman::OrderStatus SpreaderOrder::_get_order_status () const{ + SpreaderState curr_state = _state_worker == nullptr ? SpreaderState::START : _state_worker->state(); + switch (curr_state){ case SpreaderState::WORKING: return bts::api::orderman::OrderStatus::ORDER_STATUS_WORKING; case SpreaderState::WAITING_FOR_CANCEL_ALL: @@ -340,7 +304,7 @@ bts::api::orderman::OrderStatus SpreaderOrder::_get_order_status () const case SpreaderState::END: return _cancelled ? bts::api::orderman::OrderStatus::ORDER_STATUS_CANCELED : - bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; + bts::api::orderman::OrderStatus::ORDER_STATUS_COMPLETED; case SpreaderState::START: return bts::api::orderman::OrderStatus::ORDER_STATUS_INACTIVE; default: @@ -348,4 +312,4 @@ bts::api::orderman::OrderStatus SpreaderOrder::_get_order_status () const return bts::api::orderman::OrderStatus::ORDER_STATUS_INACTIVE; } } -}} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h index d30a40088..c47d9a46d 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h +++ b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.h @@ -18,7 +18,7 @@ #include "server/sparkd/orderman/events/BookUpdateEvent.h" #include "server/sparkd/mercury/events/TimerEvent.h" -using namespace bts::orderman; +//using namespace bts::orderman; namespace bts { namespace api {namespace orderman {class OrderState; class CreateSpreaderOrder;}} @@ -55,7 +55,8 @@ private: std::unique_ptr _bookkeeping_data_ptr; // pointer kept to send reports SpreaderOrderServices* _order_services; - // state thats sent out in report (its kept here vs creating a new one everytime) + // state thats sent out in report (its kept here amd modified + // vs creating a new one everytime) bts::api::orderman::OrderState _reported_state; // timestamp of last the on_time call bts::TimeStamp _curr_timestamp; @@ -65,23 +66,29 @@ private: SpreaderWorkingStateWorker _working_state_worker; SpreaderWaitingForCancelAllStateWorker _waiting_for_cancel_all_state_worker; SpreaderEndStateWorker _end_state_worker; -/**************************Cons/Dest*******************************/ +// const/dest //////////////////// +// (can not be copy/mv cons'd or +// copied either way) +////////////////////////////////// public: SpreaderOrder(); SpreaderOrder(const SpreaderOrder&)=delete; SpreaderOrder(SpreaderOrder&&)=delete; - SpreaderOrder& operator=(const SpreaderOrder&) = delete; - SpreaderOrder& operator=(SpreaderOrder&&) = delete; + SpreaderOrder& operator=(const SpreaderOrder&)=delete; + SpreaderOrder& operator=(SpreaderOrder&&)=delete; virtual ~SpreaderOrder(); -/**************************Order Derived***************************/ +// Order Derived //////////////////// +///////////////////////////////////// public: // inherited function to return the OrderDefinition. asserts // if on_init_new has not been called yet const api::orderman::OrderDefinition& definition() const override; // this is the construction, can be slow - void on_init_new(const bts::api::orderman::OrderDefinition& order_def, const bts::orderman::PreActivationOrderServices&) override; + void on_init_new(const bts::api::orderman::OrderDefinition& order_def, + const PreActivationOrderServices&) override; // called when the order is recovered from disk (not dealing with it now) - void on_init_recovered(bts::api::orderman::OrderRecord const&, const bts::orderman::PreActivationOrderServices&) override; + void on_init_recovered(bts::api::orderman::OrderRecord const&, + const PreActivationOrderServices&) override; // this is in the critical path, orders can be submitted now // (this is only called once and after the on_init_new) void on_activate(Price, Quantity, OrderServices&) override; @@ -93,32 +100,52 @@ public: // crack means to let the lower level orders lose from the higher // level order and cancel the higher level order void on_crack() override; -/*****************************ISpreaderManager*******************************/ +// ISpreaderManager //////////////////// +//////////////////////////////////////// public: - bts::orderman::OrderKey spreader_order_key() const override {return key();} - bts::TimeStamp current_time() const override {return _curr_timestamp;} - const bts::orderman::Book& get_book(size_t leg_index) const override {return _bookkeeping_data().get_leg_data(leg_index).book();} - const LegPropertyData& get_leg_data(size_t leg_index) const override {return _bookkeeping_data().get_leg_data(leg_index).leg_property_data();} + bts::orderman::OrderKey spreader_order_key() const override { + return key(); + } + bts::TimeStamp current_time() const override { + return _curr_timestamp; + } + const bts::orderman::Book& get_book(size_t leg_index) const override { + return _bookkeeping_data().get_leg_data(leg_index).book(); + } + const LegPropertyData& get_leg_data(size_t leg_index) const override { + return _bookkeeping_data().get_leg_data(leg_index).leg_property_data(); + } void setup_new_quoter_order (size_t leg_index) override; private: - /**************************Event Handlers***********************************/ - // events + // events from orders system //////////////////// + ///////////////////////////////////////////////// void _on_time (const bts::mercury::TimerEvent&); - void _on_book_update(const bts::orderman::BookUpdateEvent&); - void _on_child_order_update(const bts::orderman::OrderStateUpdateEvent&); - /***************************State Transformations***************************/ + void _on_book_update(const BookUpdateEvent&); + void _on_child_order_update(const OrderStateUpdateEvent&); + // State Transformations //////////////////// + ///////////////////////////////////////////// void _transform_to_START(); void _transform_to_WORKING(); void _transform_to_WAITING_FOR_CANCEL_ALL(); + // optionally parameter to state the end reason void _transform_to_END(std::string* m = nullptr); // swtches to the state passed in the arg void _switch_state (ISpreaderStateWorker* new_state); - /***************************Misc***************************/ - bool _inited () const {return _bookkeeping_data_ptr != nullptr;} - bool _activated () {return _order_services != nullptr;} - void _on_init_new(const bts::api::orderman::OrderDefinition&, const SpreaderPreActivationOrderServices&); + // this means on_init_new has been called and we have the + // the structure built + // misc //////////////////// + //////////////////////////// + bool _inited () const { + return _bookkeeping_data_ptr != nullptr; + } + // this means on_activate has been called + bool _activated () { + return _order_services != nullptr; + } + void _on_init_new(const bts::api::orderman::OrderDefinition&, + const SpreaderPreActivationOrderServices&); void _on_activate(Price, Quantity, SpreaderOrderServices&); - // this calls the cancel on quoter and hedger orders + // this calls the cancel on quoters and hedgers void _cancel_orders(bool cancel_quotes, bool cancel_hedges); // iterates through all quoters and returns true if they // are all in terminal state @@ -130,12 +157,15 @@ private: void _terminate_quoters (); // same as the above for hedgers void _terminate_hedgers(); + // this returns true is all quoters can accept modification bool _quoters_can_accept_modification(); // this sends a hedge (creates a hedger and inits it) // on leg 'leg_to_hedge_index' in response to a fill - // in leg 'filled_leg_index' with price 'filled_price' + // on leg 'filled_leg_index' with price 'filled_price' // quantity 'filled_quantity' - void _send_hedge(size_t filled_leg_index, Price filled_price, Quantity filled_quantity, size_t leg_to_hedge_index); + void _send_hedge(size_t filled_leg_index, Price filled_price, + Quantity filled_quantity, + size_t leg_to_hedge_index); // purely a computating function that computes the // hedge price and quantity (last 2 args) for leg // 'hedged_leg_index' for a fill on leg 'filled_leg_index' @@ -146,32 +176,38 @@ private: Price& hedge_price, Quantity& hedge_quantity); // sends the report out void _report_state (); - SpreaderBookkeepingData& _bookkeeping_data() - { + SpreaderBookkeepingData& _bookkeeping_data(){ bts_assert (_bookkeeping_data_ptr != nullptr); return *_bookkeeping_data_ptr; } - const SpreaderBookkeepingData& _bookkeeping_data() const - { + const SpreaderBookkeepingData& _bookkeeping_data() const { bts_assert (_bookkeeping_data_ptr != nullptr); return *_bookkeeping_data_ptr; } // just sets the price and qty in the bookkeeping data - void _set_price_quantity (Price price, Quantity quantity) {_bookkeeping_data().update_order (price, quantity);} + void _set_price_quantity (Price price, Quantity quantity) { + _bookkeeping_data().update_order (price, quantity); + } // returns the equivelant order status of the spreader order bts::api::orderman::OrderStatus _get_order_status () const; - static ChildOrderError _get_order_error (const bts::orderman::OrderStateUpdateEvent& ord_ev, bool expecting_cancel) - { + + static ChildOrderError _get_order_error (const OrderStateUpdateEvent& ord_ev, + bool expecting_cancel){ bts::api::orderman::OrderStatus order_status = ord_ev.state.status(); if (SpreaderUtils::order_in_error_state(order_status)) return ChildOrderError::ORDER_STATE_ERROR; if (SpreaderUtils::SpreaderUtils::order_in_cancelled_state(order_status) && !expecting_cancel) return ChildOrderError::UNEXPECTED_CANCEL_ERROR; + // this is an inelegant way to detect modify errors if (!SpreaderUtils::order_in_terminal_state(order_status) && ord_ev.state.last_msg().length() > 0) return ChildOrderError::MODIFY_ERROR; return ChildOrderError::NONE; } - /**************************Testing only***********************************/ + // testing only ////////////////// + // this provides direct way to inject + // data into the spreader, as well as + // access to the internal state + ////////////////////////////////// public: SpreaderState test_only_func_spreader_state () {return _state_worker->state();} SpreaderLegData& test_only_func_spreader_leg_data (size_t index) {return _bookkeeping_data().get_leg_data (index);} @@ -194,4 +230,4 @@ public: void test_only_on_activate(Price price, Quantity quantity, SpreaderOrderServices& order_services) {_on_activate(price, quantity, order_services);} void test_only_on_time (TimeStamp){} }; -}} +}} \ No newline at end of file diff --git a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp index f1ba07a8d..1729906ce 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/spreader_states/SpreaderWorkingStateWorker.cpp @@ -83,7 +83,8 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(SpreaderLegData& leg_data) // consider this case : // 1 lot 1 by -1 spread, both legs quoting - // leg_2 filled -> cxl leg_1's Q -> send leg_1 H -> leg_1 gets filled + // leg_2 filled -> cxl leg_1's Q -> send leg_1 H -> leg_1 + // gets filled in the meantime // in response to this unexpected fill we can // i. cxl leg_1 H (since the hedge is always sent in tandom with a reduction in the quote // - or more generally counting the total working hedges and reducing their qty) @@ -92,7 +93,9 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(SpreaderLegData& leg_data) // getting overfilled SpreaderChildOrderState& order_update_message = leg_data.order_update_message(); LOG(OrderMan, Info, "SpreaderWorkingStateWorker::on_quoter_order_fill order: key: {} order_key: {} status: {} filled_qty: {} last_price: {}", - _spreader->key(), order_update_message.order_key(), order_update_message.status(), order_update_message.last_update_filled_quantity(), order_update_message.last_update_filled_price()); + _spreader->key(), order_update_message.order_key(), order_update_message.status(), + order_update_message.last_update_filled_quantity(), + order_update_message.last_update_filled_price()); bts_assert (order_update_message.last_update_filled_quantity().value() > 0); for (size_t q_idx = 0; q_idx < _spreader->_bookkeeping_data().n_legs(); q_idx++){ SpreaderLegData& other_leg_data = _spreader->_bookkeeping_data().get_leg_data (q_idx); @@ -100,35 +103,38 @@ void SpreaderWorkingStateWorker::on_quoter_order_fill(SpreaderLegData& leg_data) // if it is an actively quoting leg, inform the quoter about it // so it can decrease the proportional size if (other_leg_data.leg_property_data().is_active_quoting()) - other_leg_data.quoter().update_other_leg_fills(leg_data.leg_property_data().leg_index(), order_update_message.last_update_filled_quantity()); + other_leg_data.quoter().update_other_leg_fills(leg_data.leg_property_data().leg_index(), + order_update_message.last_update_filled_quantity()); // a hedge is sent regardless - _spreader->_send_hedge (leg_data.leg_property_data().leg_index(), order_update_message.last_update_filled_price(), order_update_message.last_update_filled_quantity(), q_idx); + _spreader->_send_hedge (leg_data.leg_property_data().leg_index(), + order_update_message.last_update_filled_price(), + order_update_message.last_update_filled_quantity(), + q_idx); } } // this is done at the end (i dont like ordering though) because // if the order is fully filled but there is more to quote, the quoter // will generate a new order, which will modify order_update_message - // (we could have cached the last fill price and qty and called it earlier too) + // (we could have cached the last fill price and qty and called it + // earlier too) + // todo:this needs to be addressed, its confusing leg_data.quoter().update_order_status (order_update_message); } -void SpreaderWorkingStateWorker::on_quoter_order_status_update(bts::orderman::SpreaderLegData& leg_data) -{ +void SpreaderWorkingStateWorker::on_quoter_order_status_update(SpreaderLegData& leg_data){ bts_assert (leg_data.order_update_message().last_update_filled_quantity().value() == 0); leg_data.quoter().update_order_status (leg_data.order_update_message()); } -void SpreaderWorkingStateWorker::on_hedger_order_error(SingleFillHedger& hedger) -{ +void SpreaderWorkingStateWorker::on_hedger_order_error(SingleFillHedger& hedger){ hedger.on_order_update(hedger.order_state()); _spreader->_cancel_orders (true, true); _spreader->_transform_to_WAITING_FOR_CANCEL_ALL (); } -void SpreaderWorkingStateWorker::on_hedger_order_update(SingleFillHedger& hedger) -{ +void SpreaderWorkingStateWorker::on_hedger_order_update(SingleFillHedger& hedger){ hedger.on_order_update(hedger.order_state()); } -void SpreaderWorkingStateWorker::on_check_termination() -{ - if (_spreader->_all_quoter_orders_in_terminal_state() && _spreader->_all_hedger_orders_in_terminal_state()) +void SpreaderWorkingStateWorker::on_check_termination(){ + if (_spreader->_all_quoter_orders_in_terminal_state() && + _spreader->_all_hedger_orders_in_terminal_state()) _spreader->_transform_to_END (); } }} From ef1c3a7959497f8fc634517bc5fbf7cea75bf5f5 Mon Sep 17 00:00:00 2001 From: Taha Afzal Date: Wed, 6 Jun 2018 16:59:22 -0400 Subject: [PATCH 64/68] SPARK-1159 admin tool strange state --- .../api/service_helpers/AdminServiceUtils.cpp | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/src/lib/api/service_helpers/AdminServiceUtils.cpp b/src/lib/api/service_helpers/AdminServiceUtils.cpp index 6edd4935b..aef29061a 100644 --- a/src/lib/api/service_helpers/AdminServiceUtils.cpp +++ b/src/lib/api/service_helpers/AdminServiceUtils.cpp @@ -285,6 +285,22 @@ bts::api::orderman::RoutingRecord AdminServiceUtils::get_routing_record(const bt out_result.set_is_success(false); out_result.set_error_text("Could not find CME data for account"); return rv; + } + // check for data corectness + if (cme_user_data->operator_id().length() == 0){ + out_result.set_is_success(false); + out_result.set_error_text("Operator ID is not set"); + return rv; + } + if (cme_account_data->clearing_account().length() == 0){ + out_result.set_is_success(false); + out_result.set_error_text("Clearing Account is not set"); + return rv; + } + if (cme_account_data->cti()==bts::api::orderman::CTICode::CTI_CODE_UNDEFINED){ + out_result.set_is_success(false); + out_result.set_error_text("CTI Code is not set"); + return rv; } rv.set_session(conn_ptr->name()); rv.set_operator_id(cme_user_data->operator_id()); From bf9d5c2c6d9573521d05b91595feccf4415ffae1 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Wed, 6 Jun 2018 14:19:03 -0400 Subject: [PATCH 65/68] ExecutionStrategyEditor - fix vertical grid line adorner --- .../Modules/Spreader/ExecutionStrategyEditor.xaml | 11 +++++------ .../Modules/Spreader/ExecutionStrategyEditor.xaml.cs | 2 ++ .../Spreader/ExecutionStrategyGridLineAdorner.cs | 5 ++++- 3 files changed, 11 insertions(+), 7 deletions(-) diff --git a/src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml b/src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml index 96c06bb50..6055d5bfe 100644 --- a/src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml +++ b/src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml @@ -15,34 +15,33 @@ - 18 285 16 -16 15 diff --git a/src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml.cs b/src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml.cs index 410204785..06cf9dab7 100644 --- a/src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml.cs +++ b/src/client/spark/Modules/Spreader/ExecutionStrategyEditor.xaml.cs @@ -30,6 +30,8 @@ namespace mbts.ui.spark { RemovableColumnHeaderTemplateKey = "RemovableColumnHeaderTemplate", NonRemovableColumnHeaderTemplateKey = "ReadOnlyColumnHeaderTemplate", AddColumnPlaceholderKey = "AddColumnPlaceholder"; + public const double GroupLevelIndent = 18; + static ExecutionStrategyEditor() => DefaultStyleKeyProperty.OverrideMetadata(typeof(ExecutionStrategyEditor), new FrameworkPropertyMetadata(typeof(ExecutionStrategyEditor))); diff --git a/src/client/spark/Modules/Spreader/ExecutionStrategyGridLineAdorner.cs b/src/client/spark/Modules/Spreader/ExecutionStrategyGridLineAdorner.cs index c739aea82..62150b6b6 100644 --- a/src/client/spark/Modules/Spreader/ExecutionStrategyGridLineAdorner.cs +++ b/src/client/spark/Modules/Spreader/ExecutionStrategyGridLineAdorner.cs @@ -25,7 +25,10 @@ namespace mbts.ui.spark void _items_presenter_SizeChanged(object sender, SizeChangedEventArgs e) { InvalidateVisual(); } protected override void draw_vertical_line(DrawingContext dc, double x, DataGridExVerticalLine line) { - if (_items_presenter != null) dc.DrawLine(line.pen.Value, new Point(x - 10, 58), new Point(x - 10, _items_presenter.ActualHeight + 58)); + x -= GroupLevelIndent; + var start = _grid.TranslatePoint(new Point(x, _grid.super_header_height + _col_header_presenter.ActualHeight), this); + var stop = _grid.TranslatePoint(new Point(x, _grid.ActualHeight), this); + dc.DrawLine(line.pen.Value, start, stop); } } } From 9836e46dd98907578a99e0477db88b4d22266cb4 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Wed, 6 Jun 2018 14:59:48 -0400 Subject: [PATCH 66/68] SPARK-1092 Inconsitencies in changing spreader params / probably lack of persistence --- .../Orders/OrderTypeVMs/SpreaderOrderVM.cs | 58 ++++++++++++++----- .../Order/OrderDetailsPopupControl.xaml | 34 +++++++---- 2 files changed, 64 insertions(+), 28 deletions(-) diff --git a/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs index 86392c39e..2ae4de187 100644 --- a/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs @@ -1,15 +1,17 @@ using bts.api; using bts.api.orderman; using mbts.ui; +using mbts.ui.controls; using System; +using System.Collections.Generic; using System.Reactive.Linq; namespace mbts.spark { static partial class OrderTypeVMFactory { private class SpreaderOrderVM : OrderTypeVMBase, IOrderTypeVM, IDisposable { readonly Property _template; + readonly StrategyEditorWrapper _strategy_editor_wrapper; IDisposable _dispose; - SyntheticEditorVM _strategy_editor; public SpreaderOrderVM(OrdersModel model, IObservable security_source) : this(model, security_source, security_source.SelectMany(s => model.spreader.security_strategy(s.Id) @@ -26,15 +28,15 @@ namespace mbts.spark { IObservable> order_template_source) : base(model) { _template = backing(nameof(template), new SpreaderOrderDefinitionImmutable?()); + _strategy_editor_wrapper = new StrategyEditorWrapper(this); _dispose = Disposable.Create( + _strategy_editor_wrapper, _template.ObserveOnDispatcher().Subscribe(vals => { _validate(); }), order_template_source.ObserveOnDispatcher().Subscribe(prop => { if (prop.force_override || (!template.HasValue && prop.has_value)) { _template.Value = prop.value; - if (_strategy_editor != null) - _strategy_editor.set_synthetic(prop.value.Security, prop.value.ExecutionStrategy); _validate(); } }) @@ -43,23 +45,14 @@ namespace mbts.spark { } public SpreaderOrderDefinitionImmutable? template => _template.Value; - - public SyntheticEditorVM strategy_editor { - get { - if (_strategy_editor == null && template.HasValue) { - var def = template.Value; - _strategy_editor = new SyntheticEditorVM(model.spreader, def.Security, def.ExecutionStrategy, model.security_has_working_orders(def.Security.Id)); - } - return _strategy_editor; - } - } - + public SyntheticEditorVM strategy_editor => _strategy_editor_wrapper.vm; + public IEnumerable skirt_items => _strategy_editor_wrapper.skirt_items; public override bool editable_properties_open { get => base.editable_properties_open; set { - if (!value && template.HasValue && _strategy_editor != null) { + if (!value && template.HasValue && strategy_editor != null) { var mutable_template = template.Value.CloneToMutable(); - mutable_template.ExecutionStrategy = _strategy_editor.get_strategy().CloneToMutable(); + mutable_template.ExecutionStrategy = _strategy_editor_wrapper.vm.get_strategy().CloneToMutable(); _template.Value = new SpreaderOrderDefinitionImmutable(mutable_template); } base.editable_properties_open = value; @@ -80,6 +73,39 @@ namespace mbts.spark { set_error(nameof(template), "Waiting for security and/or strategy.", true); else clear_error(nameof(template)); } + + // lazily initializes SyntheticEditorVM and associated dialog skirt items + class StrategyEditorWrapper : IDisposable { + readonly SpreaderOrderVM _owner; + SyntheticEditorVM _vm; + DialogSkirtItem _save_strategy_item; + + public StrategyEditorWrapper(SpreaderOrderVM owner) { + _owner = owner; + _owner._template.Changed += _order_template_changed; + } + + public SyntheticEditorVM vm { get { _init(); return _vm; } } + public IEnumerable skirt_items { get { _init(); yield return _save_strategy_item; } } + + public void Dispose() { + Disposable.dispose(ref _vm); + _owner._template.Changed -= _order_template_changed; + } + + void _init() { + if (_vm == null && _owner.template.HasValue) { + var def = _owner.template.Value; + _vm = new SyntheticEditorVM(_owner.model.spreader, def.Security, def.ExecutionStrategy, _owner.model.security_has_working_orders(def.Security.Id)); + _save_strategy_item = new DialogSkirtItem("Save Strategy", _vm.commit); + } + } + + void _order_template_changed(SpreaderOrderDefinitionImmutable? oldval, SpreaderOrderDefinitionImmutable? newval) { + if (_vm != null && newval.HasValue) + _vm.set_synthetic(newval.Value.Security, newval.Value.ExecutionStrategy); + } + } } } } \ No newline at end of file diff --git a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml index e5d910940..fe7082c06 100644 --- a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml +++ b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml @@ -364,18 +364,28 @@ - + + + + + + + + From 5d4bb1d421378982825aae34fcfb109f0cd4b5b9 Mon Sep 17 00:00:00 2001 From: Pedro Pinto Date: Wed, 6 Jun 2018 17:15:09 -0400 Subject: [PATCH 67/68] More server side perf instrumentation. --- .../sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp | 13 ++++++++++++- src/server/sparkd/orderman/actors/MDSource.h | 3 +++ .../orderman/actors/order_manager/ChildOrder.h | 12 ++++++------ .../orderman/actors/order_manager/OrderServices.h | 12 ++++++------ .../sparkd/orderman/events/ActivateOrderEvent.h | 7 ++++++- .../sparkd/orderman/events/CancelOrderEvent.h | 4 +++- .../sparkd/orderman/events/UpdateOrderEvent.h | 7 ++++++- .../orders/spreader_orders/SpreaderOrder.cpp | 2 ++ 8 files changed, 44 insertions(+), 16 deletions(-) diff --git a/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp b/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp index 172729d8f..bb2d35b95 100644 --- a/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp +++ b/src/server/sparkd/md/platforms/mdp3_onixs/MDP3Listener.cpp @@ -2,6 +2,7 @@ #include "lib/utils/datetime.h" #include #include "server/sparkd/tracing/bts_trace.h" +#include "lib/utils/helper_macros.h" using namespace std; using namespace bts::co2; @@ -161,7 +162,16 @@ void MDP3Listener::onPacket(onixs::Handler&, const onixs::PacketArgs& args) { } } _latest_sequence = seq; - tracepoint (bts_trace,trace_order,(char*) "onPacket", 0,_latest_sequence); + auto onixs_zero = args.receiveTime().sinceEpoch(); + auto onixs_now = OnixS::CME::MDH::UtcWatch::now().sinceEpoch(); + + // needed for clang compilation + UNUSED(onixs_zero); + UNUSED(onixs_now); + // was needed for clang compilation + + tracepoint (bts_trace,trace_order,(char*) "onPacket", + _packet_arrived.to_uint64() - (onixs_now-onixs_zero),_latest_sequence); } void MDP3Listener::onEndOfPacket(onixs::Handler&, const onixs::PacketArgs&) { tracepoint (bts_trace,trace_order,(char*) "onEndOfPacket.begin", 0,_latest_sequence); @@ -680,3 +690,4 @@ md::MDP3Listener::BookData::BookData(MDProducerHandle & handle) : handle(handle) }}//namespace + diff --git a/src/server/sparkd/orderman/actors/MDSource.h b/src/server/sparkd/orderman/actors/MDSource.h index d42dea5f5..5476f7b3d 100644 --- a/src/server/sparkd/orderman/actors/MDSource.h +++ b/src/server/sparkd/orderman/actors/MDSource.h @@ -9,6 +9,7 @@ #include "server/sparkd/mercury/mercury_utils/IPollableActor.h" #include "server/sparkd/orderman/events/BookUpdateEvent.h" #include "server/sparkd/orderman/events/MDRequestEvent.h" +#include "server/sparkd/tracing/bts_trace.h" namespace bts { namespace orderman { @@ -66,6 +67,8 @@ class MDSource : public mercury::Actor, public mercury::IPollableActor { corid = handle->sequence(); LOG(Latency, Info, "MDSource {} {}", corid, utils::TimeStamp::now().to_uint64()); + + tracepoint (bts_trace,trace_order,(char*) "MDSource", 0, corid); publish(_book_update, book, corid); } } diff --git a/src/server/sparkd/orderman/actors/order_manager/ChildOrder.h b/src/server/sparkd/orderman/actors/order_manager/ChildOrder.h index 20ec70f5f..081918997 100644 --- a/src/server/sparkd/orderman/actors/order_manager/ChildOrder.h +++ b/src/server/sparkd/orderman/actors/order_manager/ChildOrder.h @@ -47,20 +47,20 @@ public: bool is_active() const {return _active;} - void activate(Price p, Quantity q) + void activate(Price p, Quantity q, TickToTradeCorID cid = 0) { bts_assert(_order); bts_assert(!_active); - _order_services->send_activate(*_order,p,q); + _order_services->send_activate(*_order,p,q, cid); _active = true; } - void update(Price p, Quantity q) + void update(Price p, Quantity q, TickToTradeCorID cid = 0) { bts_assert(_order); bts_assert(_active); - _order_services->send_update(_order->key(),p,q); + _order_services->send_update(_order->key(),p,q,cid); } void crack() @@ -70,11 +70,11 @@ public: _order_services->send_crack(_order->key()); } - void cancel() + void cancel(TickToTradeCorID cid = 0) { bts_assert(_order); bts_assert(_active); - _order_services->send_cancel(_order->key()); + _order_services->send_cancel(_order->key(),cid); } private: diff --git a/src/server/sparkd/orderman/actors/order_manager/OrderServices.h b/src/server/sparkd/orderman/actors/order_manager/OrderServices.h index 39f2520a4..0cd5c91ba 100644 --- a/src/server/sparkd/orderman/actors/order_manager/OrderServices.h +++ b/src/server/sparkd/orderman/actors/order_manager/OrderServices.h @@ -112,17 +112,17 @@ class OrderServices { friend class ChildOrder; - void send_activate(Order &o, Price p, Quantity q) { - _data.owner.publish(_data.activate_order_pub, o, p, q); + void send_activate(Order &o, Price p, Quantity q, TickToTradeCorID cid = 0) { + _data.owner.publish(_data.activate_order_pub, o, p, q,cid); } - void send_update(OrderKey k, Price p, Quantity q) { - _data.owner.publish(_data.update_order_pub, k, p, q); + void send_update(OrderKey k, Price p, Quantity q, TickToTradeCorID cid = 0) { + _data.owner.publish(_data.update_order_pub, k, p, q,cid); } void send_crack(OrderKey k) { _data.owner.publish(_data.crack_order_pub, k); } - void send_cancel(OrderKey k) { - _data.owner.publish(_data.cancel_order_pub, k); + void send_cancel(OrderKey k, TickToTradeCorID cid = 0) { + _data.owner.publish(_data.cancel_order_pub, k, cid); } Order &_owner; diff --git a/src/server/sparkd/orderman/events/ActivateOrderEvent.h b/src/server/sparkd/orderman/events/ActivateOrderEvent.h index a2fcf6240..62d986f74 100644 --- a/src/server/sparkd/orderman/events/ActivateOrderEvent.h +++ b/src/server/sparkd/orderman/events/ActivateOrderEvent.h @@ -15,12 +15,17 @@ public: using SynopsisPolicy = mercury::NoSynopsis; ActivateOrderEvent (Order &o,Price p, Quantity q) : - order (&o),price(p),quantity(q) + order (&o),price(p),quantity(q), correlation_id(0) + {} + + ActivateOrderEvent (Order &o,Price p, Quantity q,TickToTradeCorID cid) : + order (&o),price(p),quantity(q), correlation_id(cid) {} Order* order; Price price; Quantity quantity; + TickToTradeCorID correlation_id; }; }} diff --git a/src/server/sparkd/orderman/events/CancelOrderEvent.h b/src/server/sparkd/orderman/events/CancelOrderEvent.h index 4623a8331..3ec24da2d 100644 --- a/src/server/sparkd/orderman/events/CancelOrderEvent.h +++ b/src/server/sparkd/orderman/events/CancelOrderEvent.h @@ -13,11 +13,13 @@ class CancelOrderEvent : public mercury::Event public: using SynopsisPolicy = mercury::NoSynopsis; - CancelOrderEvent (OrderKey k) : k (k) {} + CancelOrderEvent (OrderKey k) : k (k), correlation_id(0) {} + CancelOrderEvent (OrderKey k,TickToTradeCorID cid) : k (k), correlation_id(cid) {} // used by ContentSubscription OrderKey key() const {return k;} OrderKey k; + TickToTradeCorID correlation_id; }; }} diff --git a/src/server/sparkd/orderman/events/UpdateOrderEvent.h b/src/server/sparkd/orderman/events/UpdateOrderEvent.h index 339df8cc0..1379107f1 100644 --- a/src/server/sparkd/orderman/events/UpdateOrderEvent.h +++ b/src/server/sparkd/orderman/events/UpdateOrderEvent.h @@ -14,7 +14,11 @@ public: using SynopsisPolicy = mercury::NoSynopsis; UpdateOrderEvent (OrderKey k, Price p, Quantity q) : - k(k), price(p), quantity(q) + k(k), price(p), quantity(q), correlation_id(0) + {} + + UpdateOrderEvent (OrderKey k, Price p, Quantity q,TickToTradeCorID cid) : + k(k), price(p), quantity(q), correlation_id(cid) {} // used by ContentSubscription @@ -23,6 +27,7 @@ public: OrderKey k; Price price; Quantity quantity; + TickToTradeCorID correlation_id; }; }} diff --git a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp index 2ebf837c9..4dcd67009 100644 --- a/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp +++ b/src/server/sparkd/orderman/orders/spreader_orders/SpreaderOrder.cpp @@ -6,6 +6,7 @@ #include "server/sparkd/orderman/orders/spreader_orders/spreader/LegPropertyData.h" #include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderLegData.h" #include "server/sparkd/orderman/orders/spreader_orders/spreader/SpreaderBookkeepingData.h" +#include "server/sparkd/tracing/bts_trace.h" namespace bts { namespace orderman { @@ -83,6 +84,7 @@ void SpreaderOrder::_on_time(const bts::mercury::TimerEvent& t_event){ } void SpreaderOrder::_on_book_update(const BookUpdateEvent& book_event){ if (!_active) return; + tracepoint (bts_trace,trace_order,(char*) "_on_book_update", 0,book_event.correlation_id); _state_worker->on_book (book_event.correlation_id, book_event.book); } void SpreaderOrder::_on_child_order_update(const OrderStateUpdateEvent& ord_ev){ From 5f845f135558fa1ca48e4e2c66ecbc785784b132 Mon Sep 17 00:00:00 2001 From: Kevin Darby Date: Wed, 6 Jun 2018 17:24:31 -0400 Subject: [PATCH 68/68] python 2.7 vs 3.6 blues --- src/client/Directory.Build.Targets | 1 + tools/buildspark.cmd | 2 ++ tools/vscode.cmd | 3 +-- 3 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/client/Directory.Build.Targets b/src/client/Directory.Build.Targets index c23904d77..c0a3999b0 100644 --- a/src/client/Directory.Build.Targets +++ b/src/client/Directory.Build.Targets @@ -39,6 +39,7 @@ nul cd /d %~dp0/../ +setlocal +set path=%spark_build_python_path%;%path% msbuild /m /nologo /p:debugtype=portable /p:platform=x64 /p:GenerateFullPaths=true /clp:verbosity=minimal /clp:summary %* spark_client.sln diff --git a/tools/vscode.cmd b/tools/vscode.cmd index 7c1f5de87..1c91de57a 100644 --- a/tools/vscode.cmd +++ b/tools/vscode.cmd @@ -4,5 +4,4 @@ cd %~dp0\.. call "C:\Program Files (x86)\Microsoft Visual Studio\2017\Professional\Common7\Tools\VsDevCmd.bat" > nul cd /d %~dp0\.. setlocal -set path=c:\python27;%path% -cmd /C start "" "C:\Program Files\Microsoft VS Code\Code.exe" "%*" -n +cmd /C start "" "C:\Program Files\Microsoft VS Code\Code.exe" "%*"