From b56a29b33df27b60f84f14aa1a2819e8fad85df5 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Sat, 24 Nov 2018 17:14:39 -0600 Subject: [PATCH] OrderTypeVMs - implement load_from(CustomOrderDefinitionImmutable) --- .../spark/Orders/OrderTypeVMs/CoverOrderVM.cs | 24 ++++++--- .../spark/Orders/OrderTypeVMs/IOrderTypeVM.cs | 3 ++ .../Orders/OrderTypeVMs/IcebergOrderVM.cs | 10 +++- .../spark/Orders/OrderTypeVMs/LeanOrderVM.cs | 31 ++++++++--- .../Orders/OrderTypeVMs/OffsetOrderVM.cs | 18 +++++-- .../Orders/OrderTypeVMs/OrderTypeVMFactory.cs | 54 ++++++++++++++++--- .../Orders/OrderTypeVMs/StopLimitOrderVM.cs | 11 +++- .../spark/Orders/OrderTypeVMs/TickOrderVM.cs | 38 ++++++++++--- .../Orders/OrderTypeVMs/TimeBoxOrderVM.cs | 5 ++ .../spark/Orders/OrderTypeVMs/TopOrderVM.cs | 25 +++++++-- .../Orders/OrderTypeVMs/TriggerOrderVM.cs | 30 ++++++++++- .../view/Spark/Utilities/OrderDataHelper.cs | 25 +++++++++ 12 files changed, 232 insertions(+), 42 deletions(-) diff --git a/src/client/spark/Orders/OrderTypeVMs/CoverOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/CoverOrderVM.cs index dfb3fa571..23a8c7c39 100644 --- a/src/client/spark/Orders/OrderTypeVMs/CoverOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/CoverOrderVM.cs @@ -1,5 +1,6 @@ using bts.api.orderman; using mbts.ui; +using mbts.ui.utilities; using mbts.ui.utility; using mbts.utils; using System; @@ -35,13 +36,13 @@ namespace mbts.spark { } - class CoverOrderVM : HierarchicalOrderTypeVMBase - { + class CoverOrderVM : HierarchicalOrderTypeVMBase { + // property backings + readonly Property _hedge_ticks; + // InlineCoverOrderProperties _inline_props; OrderSelector _hedge_selector; - public int hedge_ticks { get; set; } = 1; - public CoverOrderVM(OrdersModel model, IObservable security_md_source, string id, string display_name) : this(model, security_md_source, security_md_source.Select(smd => new InlineCoverOrderProperties(new OrderTemplateHeader(model.factory.default_order_type(smd.security)), model.factory.default_order_types(smd.security).Select(t => new OrderTemplateHeader(t)).ToList())), id, display_name) @@ -49,6 +50,9 @@ namespace mbts.spark { public CoverOrderVM(OrdersModel model, IObservable security_md_source, IObservable inline_properties, string id, string display_name) : base(model, security_md_source, id, display_name) { + // init property backings + _hedge_ticks = backing(nameof(hedge_ticks), 1); + // _hedge_selector = _mk_selector(nameof(hedge_order)); _dispose = inline_properties.OnDispatcher().Subscribe(p => { _order_selector.on_settings(p.selected_child_order_type, p.child_order_types); @@ -63,6 +67,10 @@ namespace mbts.spark { _validate(); } + public ICollection hedge_order_types => _hedge_selector.order_types; + public IOrderTypeVM hedge_order { get => _hedge_selector.value; set => _hedge_selector.value = value; } + public int hedge_ticks { get => _hedge_ticks.Value; set => _hedge_ticks.set(value); } + public override void assign_to(CustomOrderDefinition value) { _order_selector.init(); @@ -79,9 +87,11 @@ namespace mbts.spark { } } - public ICollection hedge_order_types => _hedge_selector.order_types; - - public IOrderTypeVM hedge_order { get => _hedge_selector.value; set => _hedge_selector.value = value; } + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + if (value.Cover.HasHedge) + _hedge_selector.try_load_from(value.Cover.Hedge); + } public override void Dispose() { _hedge_selector.Dispose(); diff --git a/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs b/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs index 355592e80..4cd1987ce 100644 --- a/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs @@ -1,12 +1,14 @@ using bts.api.orderman; using bts.spark; using bts.utils; +using System; using System.Collections.Generic; using System.Windows.Input; using static bts.api.orderman.CustomOrderDefinition; namespace mbts.spark { interface IOrderTypeVM : IPropertyWrapperVM { + event Action definition_changed; string id { get; } CustomOneofCase order_type { get; } string type_name { get; } @@ -15,6 +17,7 @@ namespace mbts.spark { bool has_editable_properties { get; } bool editable_properties_open { get; set; } string display_name { get; } + CustomOrderDefinitionImmutable definition { get; } bool key_match(KeyEventArgs e); void init(); } diff --git a/src/client/spark/Orders/OrderTypeVMs/IcebergOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/IcebergOrderVM.cs index 9564dcdbc..1833c921b 100644 --- a/src/client/spark/Orders/OrderTypeVMs/IcebergOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/IcebergOrderVM.cs @@ -1,5 +1,6 @@ using bts.api.orderman; using mbts.ui; +using mbts.ui.utilities; using mbts.utils; using System; using System.Collections.Generic; @@ -23,6 +24,7 @@ namespace mbts.spark { class IcebergOrderVM : HierarchicalOrderTypeVMBase { InlineIcebergOrderProperties _inline_props; + readonly Property _show_quantity; public IcebergOrderVM(OrdersModel model, IObservable security_md_source, string id, string display_name) : this(model, security_md_source, security_md_source.Select(smd => @@ -30,6 +32,7 @@ namespace mbts.spark { public IcebergOrderVM(OrdersModel model, IObservable security_md_source, IObservable inline_properties, string id, string display_name) : base(model, security_md_source, id, display_name) { + _show_quantity = backing(nameof(show_quantity), 0.0); _dispose = inline_properties.OnDispatcher().Subscribe(p => { _order_selector.on_settings(p.selected_child_order_type, p.child_order_types); if (p.show_quantity.force_override) { @@ -42,7 +45,7 @@ namespace mbts.spark { _validate(); } - public double show_quantity { get; set; } = 0; + public double show_quantity { get => _show_quantity.Value; set => _show_quantity.set(value); } public override void assign_to(CustomOrderDefinition value) { _order_selector.init(); @@ -55,6 +58,11 @@ namespace mbts.spark { } } + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + show_quantity = value.Iceberg.ShowQuantity; + } + protected override CustomOneofCase _get_default_child_order_type() => _inline_props != null && _inline_props.selected_child_order_type.has_value ? _inline_props.selected_child_order_type.value.key.type : diff --git a/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs index 37f58f7a5..12eeb36a3 100644 --- a/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/LeanOrderVM.cs @@ -1,4 +1,5 @@ using bts.api.orderman; +using bts.spark; using mbts.ui; using mbts.ui.utility; using mbts.utils; @@ -31,20 +32,25 @@ namespace mbts.spark { public readonly InlineUserProperty trade_toward_behavior; } - class LeanOrderVM : HierarchicalOrderTypeVMBase - { + class LeanOrderVM : HierarchicalOrderTypeVMBase { + // property backings + readonly Property _cross_threshold; + readonly Property _max_chase_ticks; + readonly Property _trade_toward_behavior; + // InlineLeanOrderProperties _inline_props; - public bts.spark.QuantityMeasure cross_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; - public uint max_chase_ticks { get; set; } = 2; - public LeanOrderDefinition.Types.OnToward trade_toward_behavior { get; set; } = LeanOrderDefinition.Types.OnToward.Cancel; - public LeanOrderVM(OrdersModel model, IObservable security_md_source, string id, string display_name) : this(model, security_md_source, security_md_source.Select(smd => new InlineLeanOrderProperties(new OrderTemplateHeader(model.factory.default_order_type(smd.security)), model.factory.default_order_types(smd.security).Select(t => new OrderTemplateHeader(t)).ToList())), id, display_name) { } public LeanOrderVM(OrdersModel model, IObservable security_md_source, IObservable inline_properties, string id, string display_name) : base(model, security_md_source, id, display_name) { + // init property backings + _cross_threshold = backing(nameof(cross_threshold), new QuantityMeasure { Ratio = 1.0, Absolute = 1 }); + _max_chase_ticks = backing(nameof(max_chase_ticks), 2u); + _trade_toward_behavior = backing(nameof(trade_toward_behavior), LeanOrderDefinition.Types.OnToward.Cancel); + // _dispose = inline_properties.OnDispatcher().Subscribe(p => { _order_selector.on_settings(p.selected_child_order_type, p.child_order_types); if (p.cross_threshold.force_override) { @@ -65,6 +71,11 @@ namespace mbts.spark { _validate(); } + public QuantityMeasure cross_threshold { get => _cross_threshold.Value; set => _cross_threshold.set(value); } + public uint max_chase_ticks { get => _max_chase_ticks.Value; set => _max_chase_ticks.set(value); } + public LeanOrderDefinition.Types.OnToward trade_toward_behavior { get => _trade_toward_behavior.Value; set => _trade_toward_behavior.set(value); } + public IEnumerable trade_toward_types => EnumHelper.get_values_except(); + public override void assign_to(CustomOrderDefinition value) { _order_selector.init(); @@ -80,7 +91,13 @@ namespace mbts.spark { } } - public IEnumerable trade_toward_types => EnumHelper.get_values_except(); + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + var lean_def = value.Lean; + cross_threshold = lean_def.CrossThreshold.CloneToMutable(); + max_chase_ticks = lean_def.MaxChaseTicks; + trade_toward_behavior = lean_def.TradeTowardBehavior; + } protected override CustomOneofCase _get_default_child_order_type() => _inline_props != null && _inline_props.selected_child_order_type.has_value ? diff --git a/src/client/spark/Orders/OrderTypeVMs/OffsetOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/OffsetOrderVM.cs index 7b5798970..1ae6f0537 100644 --- a/src/client/spark/Orders/OrderTypeVMs/OffsetOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/OffsetOrderVM.cs @@ -25,18 +25,21 @@ namespace mbts.spark { public readonly InlineUserProperty tick_offset_on_deploy; } - class OffsetOrderVM : HierarchicalOrderTypeVMBase - { + class OffsetOrderVM : HierarchicalOrderTypeVMBase { + // property backings + readonly Property _tick_offset_on_deploy; + // InlineOffsetOrderProperties _inline_props; - public uint tick_offset_on_deploy { get; set; } = 0; - public OffsetOrderVM(OrdersModel model, IObservable security_md_source, string id, string display_name) : this(model, security_md_source, security_md_source.Select(smd => new InlineOffsetOrderProperties(new OrderTemplateHeader(model.factory.default_order_type(smd.security)), model.factory.default_order_types(smd.security).Select(t => new OrderTemplateHeader(t)).ToList())), id, display_name) { } public OffsetOrderVM(OrdersModel model, IObservable security_md_source, IObservable inline_properties, string id, string display_name) : base(model, security_md_source, id, display_name) { + // init property backings + _tick_offset_on_deploy = backing(nameof(tick_offset_on_deploy), 0u); + // _dispose = inline_properties.OnDispatcher().Subscribe(p => { _order_selector.on_settings(p.selected_child_order_type, p.child_order_types); if (p.tick_offset_on_deploy.force_override) { @@ -48,6 +51,8 @@ namespace mbts.spark { }); _validate(); } + + public uint tick_offset_on_deploy { get => _tick_offset_on_deploy.Value; set => _tick_offset_on_deploy.set(value); } public override void assign_to(CustomOrderDefinition value) { @@ -62,6 +67,11 @@ namespace mbts.spark { } } + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + tick_offset_on_deploy = value.Offset.TickOffsetOnDeploy; + } + protected override CustomOneofCase _get_default_child_order_type() => _inline_props != null && _inline_props.selected_child_order_type.has_value ? _inline_props.selected_child_order_type.value.key.type : diff --git a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs index f579c15ee..83c9248e6 100644 --- a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs +++ b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs @@ -66,8 +66,17 @@ namespace mbts.spark { this.id = id; this.display_name = display_name; _editable_properties_open = backing(nameof(editable_properties_open)); + PropertyChanged += (s, e) => raise_definition_changed(); } + public event Action definition_changed; + public virtual CustomOrderDefinitionImmutable definition { + get { + var def = factory.custom_order(order_type); + assign_to(def); + return def; + } + } public abstract CustomOneofCase order_type { get; } public abstract string type_name { get; } public bool is_bts_type => display_name.StartsWith("BTS"); @@ -92,6 +101,8 @@ namespace mbts.spark { } protected virtual void load_from_internal(CustomOrderDefinitionImmutable value) { } + + protected void raise_definition_changed() => definition_changed?.Invoke(); } abstract class OrderTypeVMBase : OrderTypeVMBase where T : Google.Protobuf.IMessage, new() { @@ -126,6 +137,13 @@ namespace mbts.spark { Disposable.dispose(ref _dispose); } + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + var child_def = OrderDataHelper.get_child_order(value); + if (child_def.HasValue) + _order_selector.try_load_from(child_def.Value); + } + protected virtual void _validate() => _order_selector.validate(); @@ -144,7 +162,7 @@ namespace mbts.spark { _mk_selector(prop_name, _get_default_child_order_type, () => security.HasValue ? _get_default_child_order_type() : (CustomOneofCase?)null, (s, e) => _validate()); protected OrderSelector _mk_selector(string prop_name, Func get_fallback_value, Func get_best_initial_value, EventHandler on_errors_changed) { - return new OrderSelector(this, prop_name, factory, get_fallback_value, get_best_initial_value, on_errors_changed); + return new OrderSelector(this, prop_name, factory, get_fallback_value, get_best_initial_value, raise_definition_changed, on_errors_changed); IOrderTypeVM factory(OrderTemplateHeader ot) { var ovm = create(ot.key.type, ot.key.name, ot.display_name, model, _security_md_source); ovm.init(); @@ -162,16 +180,18 @@ namespace mbts.spark { readonly Lazy> _order_types; readonly Func _get_best_initial_value; readonly Func _get_fallback_value; + readonly Action _raise_definition_changed; readonly EventHandler _on_errors_changed; IOrderTypeVM _order; IDisposable _order_errors_sub; - public OrderSelector(IValidationViewModel owner, string prop_name, Func factory, Func get_fallback_value, Func get_best_initial_value, EventHandler on_errors_changed) { + public OrderSelector(IValidationViewModel owner, string prop_name, Func factory, Func get_fallback_value, Func get_best_initial_value, Action raise_definition_changed, EventHandler on_errors_changed) { _owner = owner; _prop_name = prop_name; _get_best_initial_value = get_best_initial_value; _get_fallback_value = get_fallback_value; _on_errors_changed = on_errors_changed; + _raise_definition_changed = raise_definition_changed; _order_types = new Lazy>(() => ObservableAutoWrapper.Create(_order_type_models, factory)); } @@ -209,6 +229,15 @@ namespace mbts.spark { public void select_order(CustomOneofCase ot) => _select_order(_get_best_match(ot)); + public void try_load_from(CustomOrderDefinitionImmutable def) { + if (_order == null || _order.order_type != def.CustomCase) { + select_order(def.CustomCase); + if (_order == null || _order.order_type != def.CustomCase) + return; + } + _order.load_from(def); + } + public void validate() => _owner.assert(_order != null && !((_order as INotifyDataErrorInfo)?.HasErrors ?? false), _prop_name, string.Empty); @@ -220,13 +249,22 @@ namespace mbts.spark { } } - void _select_order(IOrderTypeVM newavl) { + void _select_order(IOrderTypeVM newval) { + if (newval == _order) return; Disposable.dispose(ref _order_errors_sub); - _order = newavl; - _order?.init(); - if (_order is INotifyDataErrorInfo ndei) { - ndei.ErrorsChanged += _on_errors_changed; - _order_errors_sub = Disposable.Create(() => ndei.ErrorsChanged -= _on_errors_changed); + _order = newval; + if (_order != null) { + _order.init(); + var subs = new List(2); + if (_order is INotifyDataErrorInfo ndei) { + ndei.ErrorsChanged += _on_errors_changed; + subs.Add(Disposable.Create(() => ndei.ErrorsChanged -= _on_errors_changed)); + } + newval.definition_changed += on_definition_changed; + subs.Add(Disposable.Create(() => newval.definition_changed -= on_definition_changed)); + _order_errors_sub = Disposable.Create(subs.ToArray()); + _raise_definition_changed(); + void on_definition_changed() => _raise_definition_changed(); } _owner.raise_notify_property_changed(_prop_name); } diff --git a/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs index edb40f0ba..3e882fd0c 100644 --- a/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs @@ -24,8 +24,10 @@ namespace mbts.spark { public InlineUserProperty stop_price => _get_stop_price(); } - private class StopLimitOrderVM : OrderTypeVMBase, IDisposable { + class StopLimitOrderVM : OrderTypeVMBase, IDisposable { + // property backings UserProperty _stop_price; + // InlineStopLimitOrderProperties _inline_props = new InlineStopLimitOrderProperties(() => new InlineUserProperty(double.NaN)); IDisposable _dispose; @@ -34,7 +36,9 @@ namespace mbts.spark { internal StopLimitOrderVM(OrdersModel model, IObservable spec_source, IObservable inline_properties, string id, string display_name) : base(model, id, display_name) { + // init property backings _stop_price = new UserProperty(backing(nameof(stop_price), double.NaN)); + // _dispose = Disposable.Create( spec_source.OnDispatcher().Subscribe(s => { spec = s; @@ -74,6 +78,11 @@ namespace mbts.spark { } } + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + // TODO: the StopLimitOrderDefinition needs relative vs absolute prices to function as a useful template (talk to Pedro) + } + public void Dispose() => Disposable.dispose(ref _dispose); // no need to constantly poll the md, just check the inline props when the popup opens, and right before sending an order diff --git a/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs index 3b534f992..68ab15acf 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TickOrderVM.cs @@ -1,4 +1,5 @@ using bts.api.orderman; +using bts.spark; using mbts.ui; using mbts.utils; using System; @@ -34,15 +35,13 @@ namespace mbts.spark { public readonly InlineUserProperty detach_on_toward; } - class TickOrderVM : HierarchicalOrderTypeVMBase - { + class TickOrderVM : HierarchicalOrderTypeVMBase { + // property backings + readonly Property _tick_offset_on_deploy, _cross_ticks, _max_chase_ticks; + readonly Property _cross_threshold; + readonly Property _detach_on_toward; + // InlineTickOrderProperties _inline_props; - - 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; - public bool detach_on_toward { get; set; } = true; public TickOrderVM(OrdersModel model, IObservable security_md_source, string id, string display_name) : this(model, security_md_source, security_md_source.Select(smd => @@ -50,6 +49,13 @@ namespace mbts.spark { public TickOrderVM(OrdersModel model, IObservable security_md_source, IObservable inline_properties, string id, string display_name) : base(model, security_md_source, id, display_name) { + // init property backings + _tick_offset_on_deploy = backing(nameof(tick_offset_on_deploy), 0u); + _cross_threshold = backing(nameof(cross_threshold), new QuantityMeasure { Ratio = 1.0, Absolute = 1 }); + _cross_ticks = backing(nameof(cross_ticks), 0u); + _max_chase_ticks = backing(nameof(max_chase_ticks), 10u); + _detach_on_toward = backing(nameof(detach_on_toward), true); + // _dispose = inline_properties.OnDispatcher().Subscribe(p => { _order_selector.on_settings(p.selected_child_order_type, p.child_order_types); if (p.tick_offset_on_deploy.force_override) { @@ -78,6 +84,12 @@ namespace mbts.spark { _validate(); } + public uint tick_offset_on_deploy { get => _tick_offset_on_deploy.Value; set => _tick_offset_on_deploy.set(value); } + public QuantityMeasure cross_threshold { get => _cross_threshold.Value; set => _cross_threshold.set(value); } + public uint cross_ticks { get => _cross_ticks.Value; set => _cross_ticks.set(value); } + public uint max_chase_ticks { get => _max_chase_ticks.Value; set => _max_chase_ticks.set(value); } + public bool detach_on_toward { get => _detach_on_toward.Value; set => _detach_on_toward.set(value); } + public override void assign_to(CustomOrderDefinition value) { _order_selector.init(); @@ -95,6 +107,16 @@ namespace mbts.spark { } } + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + var tick_def = value.Tick; + tick_offset_on_deploy = tick_def.TickOffsetOnDeploy; + cross_threshold = tick_def.CrossThreshold.CloneToMutable(); + cross_ticks = tick_def.CrossTicks; + max_chase_ticks = tick_def.MaxChaseTicks; + detach_on_toward = tick_def.DetachOnToward; + } + protected override CustomOneofCase _get_default_child_order_type() => _inline_props != null && _inline_props.selected_child_order_type.has_value ? _inline_props.selected_child_order_type.value.key.type : diff --git a/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs index 8a441d5b7..5068b3ac2 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs @@ -108,6 +108,11 @@ namespace mbts.spark { } } + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + // TODO: the TimeBoxOrderDefinition needs relative vs absolute start/stop times to be a useful template (talk to Pedro) + } + protected override CustomOneofCase _get_default_child_order_type() => _inline_props != null && _inline_props.selected_child_order_type.has_value ? _inline_props.selected_child_order_type.value.key.type : diff --git a/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs index 8ebdfc903..e1ce1865c 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TopOrderVM.cs @@ -1,4 +1,5 @@ using bts.api.orderman; +using bts.spark; using mbts.ui; using mbts.utils; using System; @@ -29,13 +30,13 @@ namespace mbts.spark { public readonly InlineUserProperty top_threshold; } - class TopOrderVM : HierarchicalOrderTypeVMBase - { + class TopOrderVM : HierarchicalOrderTypeVMBase { + // property backings + readonly Property _watch_level_tick_offset; + readonly Property _top_threshold; + // InlineTopOrderProperties _inline_props; - public uint watch_level_tick_offset { get; set; } = 0; - public bts.spark.QuantityMeasure top_threshold { get; set; } = new bts.spark.QuantityMeasure() { Ratio = 1.0, Absolute = 1 }; - public TopOrderVM(OrdersModel model, IObservable security_md_source, string id, string display_name) : this(model, security_md_source, security_md_source.Select(smd => new InlineTopOrderProperties(new OrderTemplateHeader(model.factory.default_order_type(smd.security)), model.factory.default_order_types(smd.security).Select(t => new OrderTemplateHeader(t)).ToList())), id, display_name) @@ -43,6 +44,10 @@ namespace mbts.spark { public TopOrderVM(OrdersModel model, IObservable security_md_source, IObservable inline_properties, string id, string display_name) : base(model, security_md_source, id, display_name) { + // init property backings + _watch_level_tick_offset = backing(nameof(watch_level_tick_offset), 0u); + _top_threshold = backing(nameof(top_threshold), new QuantityMeasure { Ratio = 1.0, Absolute = 1 }); + // _dispose = inline_properties.OnDispatcher().Subscribe(p => { _order_selector.on_settings(p.selected_child_order_type, p.child_order_types); if (p.watch_level_tick_offset.force_override) { @@ -59,6 +64,9 @@ namespace mbts.spark { _validate(); } + public uint watch_level_tick_offset { get => _watch_level_tick_offset.Value; set => _watch_level_tick_offset.set(value); } + public QuantityMeasure top_threshold { get => _top_threshold.Value; set => _top_threshold.set(value); } + public override void assign_to(CustomOrderDefinition value) { _order_selector.init(); @@ -73,6 +81,13 @@ namespace mbts.spark { } } + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + var top_def = value.Top; + watch_level_tick_offset = top_def.WatchLevelTickOffset; + top_threshold = top_def.TopThreshold.CloneToMutable(); + } + protected override CustomOneofCase _get_default_child_order_type() => _inline_props != null && _inline_props.selected_child_order_type.has_value ? _inline_props.selected_child_order_type.value.key.type : diff --git a/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs index 20c9ed81d..d57ea503d 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs @@ -136,7 +136,35 @@ namespace mbts.spark { value.Trigger = i; } } - + + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + base.load_from_internal(value); + var trigger_def = value.Trigger; + if (trigger_def.HasTriggerCondition) { + trigger_price_type = trigger_def.TriggerCondition.PriceType; + } + if (trigger_def.HasExitCondition) { + var exit_condition = trigger_def.ExitCondition; + is_priceout_checked = exit_condition.ConditionalCancel; + is_timeout_checked = exit_condition.TimeoutEnabled; + if (exit_condition.TimeoutSeconds < int.MaxValue) + timeout_secs = (int)exit_condition.TimeoutSeconds; + } + if (trigger_def.HasTriggerAction) { + var trigger_action = trigger_def.TriggerAction; + if (trigger_action.HasPayup) { + use_fixed_price = false; + fixed_price = double.NaN; + var payup = trigger_action.Payup; + payup_ticks = payup.PayupTicks; + payup_price_type = payup.PayupPriceType; + } else { + use_fixed_price = true; + fixed_price = trigger_action.Price; + } + } + } + protected override CustomOneofCase _get_default_child_order_type() => _inline_props != null && _inline_props.selected_child_order_type.has_value ? _inline_props.selected_child_order_type.value.key.type : diff --git a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs index e9ef09d5b..6025a7c2a 100644 --- a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs @@ -351,6 +351,31 @@ namespace mbts.spark.utilities { } } + public static CustomOrderDefinitionImmutable? get_child_order(CustomOrderDefinitionImmutable def) { + switch (def.CustomCase) { + case CustomOrderDefinition.CustomOneofCase.Iceberg: return _get_iceberg_child(def.Iceberg); + case CustomOrderDefinition.CustomOneofCase.TimeBox: return _get_time_box_child(def.TimeBox); + case CustomOrderDefinition.CustomOneofCase.Tick: return _get_tick_child(def.Tick); + case CustomOrderDefinition.CustomOneofCase.Lean: return _get_lean_child(def.Lean); + case CustomOrderDefinition.CustomOneofCase.Join: return _get_join_child(def.Join); + case CustomOrderDefinition.CustomOneofCase.Top: return _get_top_child(def.Top); + case CustomOrderDefinition.CustomOneofCase.Cover: return _get_cover_child(def.Cover); + case CustomOrderDefinition.CustomOneofCase.Offset: return _get_offset_child(def.Offset); + case CustomOrderDefinition.CustomOneofCase.Trigger: return _get_trigger_child(def.Trigger); + default: return null; + } + } + + static CustomOrderDefinitionImmutable? _get_iceberg_child(IcebergOrderDefinitionImmutable iceberg) => iceberg.HasChild ? iceberg.Child : (CustomOrderDefinitionImmutable?)null; + static CustomOrderDefinitionImmutable? _get_time_box_child(TimeBoxOrderDefinitionImmutable time_box) => time_box.HasChild ? time_box.Child : (CustomOrderDefinitionImmutable?)null; + static CustomOrderDefinitionImmutable? _get_tick_child(TickOrderDefinitionImmutable tick) => tick.HasChild ? tick.Child : (CustomOrderDefinitionImmutable?)null; + static CustomOrderDefinitionImmutable? _get_lean_child(LeanOrderDefinitionImmutable lean) => lean.HasChild ? lean.Child : (CustomOrderDefinitionImmutable?)null; + static CustomOrderDefinitionImmutable? _get_join_child(JoinOrderDefinitionImmutable join) => join.HasChild ? join.Child : (CustomOrderDefinitionImmutable?)null; + static CustomOrderDefinitionImmutable? _get_top_child(TopOrderDefinitionImmutable top) => top.HasChild ? top.Child : (CustomOrderDefinitionImmutable?)null; + static CustomOrderDefinitionImmutable? _get_cover_child(CoverOrderDefinitionImmutable cover) => cover.HasChild ? cover.Child : (CustomOrderDefinitionImmutable?)null; + static CustomOrderDefinitionImmutable? _get_offset_child(OffsetOrderDefinitionImmutable offset) => offset.HasChild ? offset.Child : (CustomOrderDefinitionImmutable?)null; + static CustomOrderDefinitionImmutable? _get_trigger_child(TriggerOrderDefinitionImmutable trigger) => trigger.HasChild ? trigger.Child : (CustomOrderDefinitionImmutable?)null; + public static class Defaults { public static QuantityMeasure QuantityMeasure => new QuantityMeasure { Absolute = 1 }; public static PriceType PriceType => new PriceType { Status = PriceType.Types.Status.Bid };