From a46982333bf93c829111d170c8ae5cb74c4ff7f0 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Fri, 15 Mar 2019 19:52:54 -0500 Subject: [PATCH] SPARK-2158 Algo Studio Orders are Attachable --- .../AlgoStudio/Utils/AlgoCollectionHelper.cs | 12 ++ .../Trading/AlgoStudio/VM/AlgoVMWrapper.cs | 198 ++++++++++++++++++ .../AlgoStudio/View/AlgoEditorView.xaml | 2 +- .../Modules/Trading/OrderBook/OrderBookVM.cs | 24 ++- .../Orders/OrderTypeVMs/DefaultAlgoVM.cs | 2 + .../spark/Orders/OrderTypeVMs/IOrderTypeVM.cs | 1 + .../Order/AlgoContentTemplateSelector.xaml.cs | 6 +- .../view/Spark/Utilities/OrderDataHelper.cs | 6 +- .../spark_core/utils/GlobalExtensions.cs | 3 + 9 files changed, 247 insertions(+), 7 deletions(-) create mode 100644 src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoVMWrapper.cs diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoCollectionHelper.cs b/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoCollectionHelper.cs index 27b9a9756..977153509 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoCollectionHelper.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoCollectionHelper.cs @@ -34,6 +34,18 @@ namespace mbts.spark { } } + public static void update_persisted_definition_wrappers(ObservableKeyedCollection target, TableUpdate update, Func factory) { + foreach (var d in update.removed) + target.Remove(d.key); + foreach (var d in update.changed) + target[d.key].load_from(d.value); + foreach (var d in update.added) { + if (target.TryGetValue(d.key, out IAlgoVM def)) { + def.load_from(d.value); + } else target.Add(new AlgoVMWrapper(factory(d))); + } + } + static class _CompareUtils { public static int compare_modes(AlgoDefinitionVM a, AlgoDefinitionVM b) => _compare_modes(a.key.mode, b.key.mode); diff --git a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoVMWrapper.cs b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoVMWrapper.cs new file mode 100644 index 000000000..569e4d1cb --- /dev/null +++ b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoVMWrapper.cs @@ -0,0 +1,198 @@ +using bts.api; +using bts.api.orderman; +using bts.spark; +using mbts.spark.utilities; +using mbts.ui; +using mbts.ui.controls; +using mbts.ui.shell; +using mbts.utils; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Collections.Specialized; +using System.ComponentModel; +using System.Reactive.Disposables; +using System.Reactive.Linq; +using System.Threading.Tasks; +using System.Windows.Input; + +namespace mbts.spark { + class AlgoVMWrapper : DisposableViewModelBase, IAlgoVM, + IObserver, + IObserver, + IObserver, + IObserver { + static readonly HashSet + _algo_root_echo_props = new HashSet { + nameof(is_expanded), + nameof(editing_permissions), + nameof(definition), + nameof(display_name) + }, + _value_echo_props = new HashSet { + nameof(AlgoDefinitionVM.name), + nameof(AlgoDefinitionVM.abbreviation), + nameof(AlgoDefinitionVM.badge_fill), + nameof(AlgoDefinitionVM.can_undo), + nameof(AlgoDefinitionVM.can_redo) + }; + readonly ObservableAggregateCollection _child_algo_selectors = new ObservableAggregateCollection(); + readonly DisposableContainer _value_hooks = new DisposableContainer(); + Action _definition_changed = () => { }; + _ObservedData? _data_cache; + AlgoDefinitionVM _value; + + public AlgoVMWrapper(AlgoDefinitionVM algo_definition_vm) { + value = algo_definition_vm; + _dispose = new CompositeDisposable(_value_hooks) { + _child_algo_selectors.clear_collections, + () => _value?.Dispose() + }; + } + + public event Action definition_changed { add => _definition_changed += value; remove => _definition_changed -= value; } + + public AlgoDefinitionVM value { + get => _value; + set { + if (_value != value) { + _value?.Dispose(); + _value = value; + _value_hooks.replace(_set_hooks(value)); + RaisePropertyChanged(nameof(value)); + } + } + } + public AlgoKey id => _value.key; + public CustomOrderDefinition.CustomOneofCase order_type => _algo_root?.order_type ?? CustomOrderDefinition.CustomOneofCase.None; + public bool is_bts_type => _algo_root?.is_bts_type ?? false; + public OrderMetadata meta { + get { + if (_value != null) { + if (_value.custom_badge_color.enabled) + return new OrderMetadata { Color = value.custom_badge_color.value.rgb_color(), KeyBinding = value.abbreviation.if_null_or_empty(value.name) }; + else if (_value.algo_root != null) + return _value.algo_root.meta; + } + return OrderDataHelper.get_metadata(order_type); + } + } + public AlgoEditingPermissions editing_permissions => _value?.editing_permissions ?? AlgoEditingPermissions.None; + public bool can_expand => _algo_root?.can_expand ?? false; + public bool is_expanded { + get => _value.algo_root?.is_expanded ?? false; + set { + if (_value != null) + _value.is_expanded = value; + } + } + public string display_name => _value?.name ?? string.Empty; + public CustomOrderDefinitionImmutable definition => _algo_root?.definition ?? new CustomOrderDefinitionImmutable(new CustomOrderDefinition()); + public ObservableCollection child_algo_selectors => _child_algo_selectors; + public dynamic children_vm => _algo_root?.children_vm; + + IAlgoVM _algo_root => _value?.algo_root; + + public void assign_to(CustomOrderDefinition value) => _algo_root?.assign_to(value); + public bool key_match(KeyEventArgs e) => _algo_root?.key_match(e) ?? false; + public void load_from(CustomOrderDefinitionImmutable value) => _algo_root?.load_from(value); + public Task load_from_async(CustomOrderDefinitionImmutable definition) => _algo_root is IAlgoVM vm ? vm.load_from_async(definition) : Task.FromResult(null); + + IDisposable _set_hooks(AlgoDefinitionVM vm) { + var algo_root_subs = new DisposableContainer(); + vm.PropertyChanged += on_value_prop_changed; + return new CompositeDisposable( + vm.observe_algo_root().Subscribe(r => { + algo_root_subs.replace(null); + _child_algo_selectors.clear_collections(); + if (r != null) { + if (_data_cache.HasValue) { + _data_cache.Value.forward_to(r); + } + _child_algo_selectors.add_collection(r.child_algo_selectors); + ((INotifyPropertyChanged)r).PropertyChanged += on_algo_root_prop_changed; + algo_root_subs.replace(new CompositeDisposable( + r.subscribe_definition().Subscribe(_ => _definition_changed?.Invoke())) { + () => ((INotifyPropertyChanged)r).PropertyChanged -= on_algo_root_prop_changed + }); + } + }), + algo_root_subs) { + () => vm.PropertyChanged -= on_value_prop_changed + }; + void on_algo_root_prop_changed(object sender, PropertyChangedEventArgs e) { + if (_algo_root_echo_props.Contains(e.PropertyName)) + RaisePropertyChanged(e.PropertyName); + } + void on_value_prop_changed(object sender, PropertyChangedEventArgs e) { + if (_value_echo_props.Contains(e.PropertyName)) + RaisePropertyChanged(e.PropertyName); + } + } + + // permissions + void IObserver.OnNext(AlgoEditingPermissions value) { + _data_cache = _data_cache?.with(value) ?? new _ObservedData(value, default, default, default); + (_algo_root as IObserver)?.OnNext(value); + } + void IObserver.OnError(Exception error) { } + void IObserver.OnCompleted() { } + // model + void IObserver.OnNext(OrdersModel value) { + _data_cache = _data_cache?.with(value) ?? new _ObservedData(default, value, default, default); + (_algo_root as IObserver)?.OnNext(value); + } + void IObserver.OnError(Exception error) { } + void IObserver.OnCompleted() { } + // security + void IObserver.OnNext(SecurityImmutable? value) { + _data_cache = _data_cache?.with(value) ?? new _ObservedData(default, default, value, default); + (_algo_root as IObserver)?.OnNext(value); + } + void IObserver.OnError(Exception error) { } + void IObserver.OnCompleted() { } + // security md + void IObserver.OnNext(SecurityMD? value) { + _data_cache = _data_cache?.with(value) ?? new _ObservedData(default, default, default, value); + (_algo_root as IObserver)?.OnNext(value); + } + void IObserver.OnError(Exception error) { } + void IObserver.OnCompleted() { } + + struct _ObservedData { + public readonly AlgoEditingPermissions permissions; + public readonly OrdersModel model; + public readonly SecurityImmutable? security; + public readonly SecurityMD? security_md; + + public _ObservedData(AlgoEditingPermissions permissions, OrdersModel model, SecurityImmutable? security, SecurityMD? security_md) { + this.permissions = permissions; + this.model = model; + this.security = security; + this.security_md = security_md; + } + + public void forward_to(IAlgoVM recipient) { + (recipient as IObserver)?.OnNext(permissions); + if (model != null) + (recipient as IObserver)?.OnNext(model); + if (security_md.HasValue) + (recipient as IObserver)?.OnNext(security_md); + if (security.HasValue) + (recipient as IObserver)?.OnNext(security); + } + + public _ObservedData with(AlgoEditingPermissions? permissions) => + new _ObservedData(permissions ?? this.permissions, model, security, security_md); + + public _ObservedData with(OrdersModel model) => + new _ObservedData(permissions, model, security, security_md); + + public _ObservedData with(SecurityImmutable? security) => + new _ObservedData(permissions, model, security, security_md); + + public _ObservedData with(SecurityMD? security_md) => + new _ObservedData(permissions, model, security, security_md); + } + } +} \ No newline at end of file diff --git a/src/client/spark/Modules/Trading/AlgoStudio/View/AlgoEditorView.xaml b/src/client/spark/Modules/Trading/AlgoStudio/View/AlgoEditorView.xaml index 2e5d378cb..1336d487a 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/View/AlgoEditorView.xaml +++ b/src/client/spark/Modules/Trading/AlgoStudio/View/AlgoEditorView.xaml @@ -106,7 +106,7 @@ (x.added.Values, x.removed.Values))); @@ -142,7 +143,24 @@ namespace mbts.spark { } } - void on_begin_attaching() => Disposable.replace(ref attach_vm_hooks, connect_common_selected_params(attach_vm)); + void on_begin_attaching() { + Disposable.replace(ref attach_vm_hooks, + Disposable.Create( + connect_common_selected_params(attach_vm), + // custom templates (created by user) + _model.algo_model.definitions.OnDispatcher().Subscribe(u => + AlgoCollectionHelper.update_persisted_definition_wrappers(attach_vm.algo_vm.algo_roots as ObservableKeyedCollection, u, mk_factory(true))), + // factory templates (based on security) + _selected_params_mon.subscribe_security().Select(model.factory.default_algos).Table(s => s.key).Subscribe(factory_defs => + AlgoCollectionHelper.update_persisted_definition_wrappers(attach_vm.algo_vm.algo_roots as ObservableKeyedCollection, factory_defs, mk_factory(false))))); + // vm factory + Func mk_factory(bool connect) => + fd => { + var vm = AlgoDefinitionVM.create(_model, fd, connect, OrderDataHelper.get_algo_format(_selected_params_mon.security?.ContractCase)); + vm.selected_format = OrderDataHelper.get_algo_format(_selected_params_mon.security?.ContractCase); + return vm; + }; + } void on_end_attaching() => Disposable.dispose(ref attach_vm_hooks); IDisposable connect_common_selected_params(OrderParamsVM vm) => diff --git a/src/client/spark/Orders/OrderTypeVMs/DefaultAlgoVM.cs b/src/client/spark/Orders/OrderTypeVMs/DefaultAlgoVM.cs index 3aadafe41..d97bc9212 100644 --- a/src/client/spark/Orders/OrderTypeVMs/DefaultAlgoVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/DefaultAlgoVM.cs @@ -41,6 +41,7 @@ namespace mbts.spark { public string display_name => impl?.display_name ?? "(Default)"; public AlgoDefi definition => _definition.value; public ObservableCollection child_algo_selectors { get; } = new ObservableCollection(); + public dynamic children_vm => impl?.children_vm; public void assign_to(AlgoDef value) => value.MergeFrom(definition.CloneToMutable()); public bool key_match(KeyEventArgs e) => false; @@ -105,6 +106,7 @@ namespace mbts.spark { definition_changed?.Invoke(); if (order_type != orig_def.CustomCase) RaisePropertyChanged(nameof(order_type), nameof(meta)); + RaisePropertyChanged(nameof(children_vm)); } } } diff --git a/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs b/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs index ebfdf60b5..9228339f9 100644 --- a/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs @@ -28,6 +28,7 @@ namespace mbts.spark { string display_name { get; } CustomOrderDefinitionImmutable definition { get; } ObservableCollection child_algo_selectors { get; } + dynamic children_vm { get; } bool key_match(KeyEventArgs e); Task load_from_async(CustomOrderDefinitionImmutable definition); } diff --git a/src/client/spark/view/Controls/Order/AlgoContentTemplateSelector.xaml.cs b/src/client/spark/view/Controls/Order/AlgoContentTemplateSelector.xaml.cs index d5811646f..9e1110cd8 100644 --- a/src/client/spark/view/Controls/Order/AlgoContentTemplateSelector.xaml.cs +++ b/src/client/spark/view/Controls/Order/AlgoContentTemplateSelector.xaml.cs @@ -12,11 +12,13 @@ namespace mbts.ui.spark { TemplateDropDownStyleKey = nameof(TemplateDropDownStyleKey), TriggerTimeoutEnabledStateName = nameof(TriggerTimeoutEnabledStateName); - public static readonly IValueConverter AlgoDropDownStyleKeyConverter = ValueConverter.create(obj => { + public static readonly IValueConverter + AlgoDropDownStyleKeyConverter = ValueConverter.create(obj => { if (obj is AlgoDefinitionTemplateVM t) return TemplateDropDownStyleKey; if (obj is AlgoDefinitionVM d) return DefinitionDropDownStyleKey; return null; - }); + }), + DataContextConverter = ValueConverter.create(obj => obj is AlgoVMWrapper w ? w.value.algo_root : obj); public static IMultiValueConverter TriggerTimeoutStateConverter = ValueConverter.create((is_timeout_enabled, editing_permissions) => diff --git a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs index a21f260b2..3183d7e9a 100644 --- a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs @@ -397,6 +397,9 @@ namespace mbts.spark.utilities { } } + public static AlgoFormats get_algo_format(Security.ContractOneofCase? security_type) => + security_type.HasValue ? get_algo_format(security_type.Value) : AlgoFormats.Exchange; + public static AlgoFormats get_algo_format(Security.ContractOneofCase security_type) => security_type == Security.ContractOneofCase.Synthetic ? AlgoFormats.Spreader : AlgoFormats.Exchange; @@ -905,7 +908,8 @@ namespace mbts.spark.utilities { public static BTSIcebergOrder BTSIcebergOrder => new BTSIcebergOrder { DisplayQuantity = QuantityMeasure, MarketOffset = PriceOffset, PriceTrigger = PriceTrigger, TimedWindowParameters = TimeWindow, WithatickParameters = WithATick }; // core data types - public static AlgoData AlgoData => new AlgoData(CustomOrderDefinitionImmutable()); + public static AlgoData AlgoData() => new AlgoData(CustomOrderDefinitionImmutable()); + public static AlgoData AlgoData(CustomOrderDefinition.CustomOneofCase algo_type) => new AlgoData(CustomOrderDefinitionImmutable(algo_type)); public static OrderDefinition OrderDefinition => new OrderDefinition { CustomDef = new CustomOrderDefinition() }; public static OrderRecord OrderRecord => new OrderRecord { diff --git a/src/client/spark_core/utils/GlobalExtensions.cs b/src/client/spark_core/utils/GlobalExtensions.cs index ee291796b..7433968b4 100644 --- a/src/client/spark_core/utils/GlobalExtensions.cs +++ b/src/client/spark_core/utils/GlobalExtensions.cs @@ -25,6 +25,9 @@ namespace mbts { return str; } + public static string if_null_or_empty(this string str, string default_value) => + string.IsNullOrEmpty(str) ? default_value : str; + public static T choose(this Random r, IEnumerable range) { var index = r.Next(0, range.Count()); return range.Skip(index).First();