From 60c66fb2f1fba97002f83120d0e2536e2012fdd3 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Tue, 19 Feb 2019 09:14:19 -0600 Subject: [PATCH] in spreader ladders, fix the loading of 'default' algo type --- .../AlgoStudioDefinitionTemplateModel.cs | 2 - .../Model/AlgoStudioFlatDefinitionModel.cs | 39 -------------- .../AlgoStudio/Model/IAlgoStudioModel.cs | 1 - .../Utils/AlgoDefinitionVMCollectionHelper.cs | 1 + .../Trading/AlgoStudio/VM/AlgoDefinitionVM.cs | 1 + .../spark/Orders/OrderPropertiesEditorVM.cs | 13 ++++- .../Orders/OrderTypeVMs/DynamicOrderVM.cs | 8 ++- .../Orders/OrderTypeVMs/OrderTypeVMFactory.cs | 54 ++++++++++++++++++- .../Orders/OrderTypeVMs/TriggerOrderVM.cs | 8 +-- .../view/Spark/Utilities/OrderDataHelper.cs | 2 +- 10 files changed, 71 insertions(+), 58 deletions(-) diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioDefinitionTemplateModel.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioDefinitionTemplateModel.cs index afcfb5b76..1e0f3b8b9 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioDefinitionTemplateModel.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioDefinitionTemplateModel.cs @@ -63,8 +63,6 @@ namespace mbts.spark { public IObservable> subscribe_definition_templates(AlgoKey definition) => _definition_templates_demuxer.subscribe(definition); - public IObservable> subscribe_security_definitions(IObservable security_source) => throw new NotImplementedException(); - public async Task save_definition(AlgoData definition_data) { if (definition_data.key.is_persisted) { // TODO: implement update op when backend ready diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioFlatDefinitionModel.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioFlatDefinitionModel.cs index 83c47fb29..d71801748 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioFlatDefinitionModel.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/AlgoStudioFlatDefinitionModel.cs @@ -38,45 +38,6 @@ namespace mbts.spark { public IObservable> subscribe_definition_templates(AlgoKey definition_key) => Observable.Return(TableUpdate.mk_empty(t => t.key)); - public IObservable> subscribe_security_definitions(IObservable security_source) { - return Observable.Create>(o => { - TableUpdate last = TableUpdate.mk_empty(d => d.key); - SecurityImmutable? sec = null; - var sec_sub = security_source.Subscribe(s => { - sec = s; - var builder = last.to_builder(); - foreach (var d in last.state.Values) { - var fd = OrderDataHelper.fit_to_type(d.value, s.ContractCase); - if (fd == null) - builder.remove(d.key); - else builder.add_or_update(d.with(fd)); - } - last = builder.to_table(); - o.OnNext(last); - }); - var def_sub = definitions.Subscribe(table => { - if (!sec.HasValue) { - last = table; - o.OnNext(table); - } - var builder = last.to_builder(); - foreach (var d in table.removed.Concat(table.changes.Select(ch => ch.Old))) { - var fd = OrderDataHelper.fit_to_type(d.value, sec.Value.ContractCase); - if (fd != null) - builder.remove(d.key); - } - foreach (var d in table.added.Concat(table.changed)) { - var fd = OrderDataHelper.fit_to_type(d.value, sec.Value.ContractCase); - if (fd != null) - builder.add_or_update(d.key, d.with(fd)); - } - last = builder.to_table(); - o.OnNext(last); - }); - return Disposable.Create(sec_sub, def_sub); - }); - } - public async Task save_definition(AlgoData definition_data) { if (_try_get_user(out uint user_id)) { var (value, success) = await _error_reporter.safe_execute(() => _service.save_algo_definition_async( diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Model/IAlgoStudioModel.cs b/src/client/spark/Modules/Trading/AlgoStudio/Model/IAlgoStudioModel.cs index 730d59d3a..0d2b85cbe 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Model/IAlgoStudioModel.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Model/IAlgoStudioModel.cs @@ -17,7 +17,6 @@ namespace mbts.spark { Task save_template(AlgoTemplateData template_data); Task remove_definition(AlgoKey definition_key); Task remove_template(AlgoKey template_key); - IObservable> subscribe_security_definitions(IObservable security_source); bts.config.AlgoStudioOptions ui_configuration { get; } } diff --git a/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoDefinitionVMCollectionHelper.cs b/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoDefinitionVMCollectionHelper.cs index 6acefd9c5..fc0ce2267 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoDefinitionVMCollectionHelper.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/Utils/AlgoDefinitionVMCollectionHelper.cs @@ -5,6 +5,7 @@ using mbts.ui.utilities; using mbts.utils; using System; using System.Collections.Generic; +using System.Threading.Tasks; namespace mbts.spark { static class AlgoDefinitionVMCollectionHelper { diff --git a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs index d9cd3b1ee..bd740c708 100644 --- a/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs +++ b/src/client/spark/Modules/Trading/AlgoStudio/VM/AlgoDefinitionVM.cs @@ -16,6 +16,7 @@ using System.Collections.Specialized; using System.Linq; using System.Reactive.Disposables; using System.Reactive.Linq; +using System.Threading.Tasks; using System.Windows.Data; using System.Windows.Media; using VisualStateNames = mbts.ui.spark.AlgoStudioView.VisualStateNames; diff --git a/src/client/spark/Orders/OrderPropertiesEditorVM.cs b/src/client/spark/Orders/OrderPropertiesEditorVM.cs index 2538606cf..072a9021c 100644 --- a/src/client/spark/Orders/OrderPropertiesEditorVM.cs +++ b/src/client/spark/Orders/OrderPropertiesEditorVM.cs @@ -184,7 +184,7 @@ namespace mbts.spark { return vm; }); }), - model.algo_model.subscribe_security_definitions(security_md_source.Select(smd => smd.security)).Subscribe(_definitions_buffer), + model.algo_model.definitions.Subscribe(_definitions_buffer), _definitions_buffer.OnDispatcher().Subscribe(u => { AlgoDefinitionVMCollectionHelper.update_persisted_definitions(_algo_definitions, u, def_data => { var def_vm = AlgoDefinitionVM.create(model, def_data, true, OrderDataHelper.get_algo_format(security.ContractCase)); @@ -194,7 +194,16 @@ namespace mbts.spark { }); }), model.algo_model.metadata_service.subscribe_metadata().OnDispatcher().Subscribe(_on_template_metadata), - ObservableAutoWrapper.connect_item_hooks(algo_definitions, vm => Disposable.Create(vm.connect_data(Observable.Return(_model)), vm.connect_data(nullable_security_md_source), vm), true)) { + ObservableAutoWrapper.connect_item_hooks(algo_definitions, vm => + Disposable.Create( + vm.connect_data(Observable.Return(_model)), + vm.connect_data(nullable_security_md_source), + security_source.Subscribe(s => { + var fmt = OrderDataHelper.get_algo_format(s.ContractCase); + foreach (var d in algo_definitions) + d.selected_format = fmt; + }), + vm), true)) { () => Disposable.dispose(ref _template_collection_sync) }; async Task save_template_async(AlgoDefinitionTemplateVM template) { diff --git a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs index 0e1ed22ab..62cf4c644 100644 --- a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs @@ -11,7 +11,7 @@ using System.Threading.Tasks; namespace mbts.spark { static partial class OrderTypeVMFactory { - class DynamicOrderVM : OrderTypeVMBase, IObserver { + class DynamicOrderVM : OrderTypeVMBase { readonly ObservableKeyedCollection _parameters = new ObservableKeyedCollection(vm => vm.descriptor.ParamName); readonly Property _dyn_type; OrdersModel _model; @@ -65,9 +65,7 @@ namespace mbts.spark { _reset_dynamic_types(); } } - void IObserver.OnCompleted() { } - void IObserver.OnError(Exception error) { } - void IObserver.OnNext(OrdersModel model) { + protected override void on_model_internal(OrdersModel model) { _model = model; _reset_dynamic_types(); } @@ -132,4 +130,4 @@ namespace mbts.spark { } } } -} \ No newline at end of file +} diff --git a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs index ddba10039..84cb18d10 100644 --- a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs +++ b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs @@ -107,7 +107,7 @@ namespace mbts.spark { } #region OrderTypeVM Base Classes - abstract class OrderTypeVMBase : DisposableViewModelBase, IAlgoVM where TMutable : class, IMessage, new() where TImmutable : struct, IImmutableMessage { + abstract class OrderTypeVMBase : DisposableViewModelBase, IAlgoVM, IObserver, IObserver where TMutable : class, IMessage, new() where TImmutable : struct, IImmutableMessage { /// TODO: maybe use explicit delegates rather than rely on reflection . static readonly FieldDescriptor _descriptor = OrderTypeVMUtils.find_descriptor(); static readonly Func _create_immutable = OrderTypeVMUtils.immutable_factory(); @@ -190,6 +190,9 @@ namespace mbts.spark { public bool can_edit_structure => EnumHelper.includes_flag(editing_permissions, AlgoEditingPermissions.AllowEditStructure); public bool can_save_values => _can_save_values.Value; public bool can_save_structure => _can_save_structure.Value; + protected OrdersModel model { get; private set; } + protected SecurityMD? security_md { get; private set; } + protected SecurityImmutable? security => security_md?.security; public void assign_to(AlgoDef value) { var algo = new TMutable(); @@ -219,6 +222,11 @@ namespace mbts.spark { foreach (var sd in _child_algo_selector_data) { var inner_def = sd.get_order(value); if (inner_def.HasValue) { + if (security.HasValue) { + inner_def = OrderDataHelper.fit_to_type(inner_def.Value, security.Value.ContractCase); + if (!inner_def.HasValue) + continue; + } var vm = sd.selector.algos.GetOrAdd(OrderDataHelper.get_shallow_factory_key(inner_def.Value), k => create(k, inner_def.Value.display_name(), inner_def.Value.CustomCase)); vm.load_from(inner_def.Value); sd.selector.selected_algo = vm; @@ -382,6 +390,50 @@ namespace mbts.spark { }, def => { set_local(get_from_def(def)); })); + + protected virtual void on_model_internal(OrdersModel model) { } + protected virtual void on_security_md_internal(SecurityMD? security_md) { } + + // format + //void IObserver.OnNext(OrdersModel model) { + // this.model = model; + // on_model_internal(model); + // _reset(); + //} + //void IObserver.OnError(Exception error) { } + //void IObserver.OnCompleted() { } + // model + void IObserver.OnNext(OrdersModel model) { + this.model = model; + on_model_internal(model); + _reset(); + } + void IObserver.OnError(Exception error) { } + void IObserver.OnCompleted() { } + // security md + void IObserver.OnNext(SecurityMD? security_md) { + this.security_md = security_md; + on_security_md_internal(security_md); + _reset(); + } + void IObserver.OnError(Exception error) { } + void IObserver.OnCompleted() { } + + IDisposable _hook; + void _reset() { + if (model != null && security.HasValue) { + var algo_data = model.factory.default_algos(security.Value); + var default_algo = new AlgoKey(OrderDataHelper.get_default_algo(OrderDataHelper.get_algo_format(security.Value.ContractCase))); + foreach (var sd in _child_algo_selectors) + sd.load_algo_data_recursive(algo_data, default_algo); + Disposable.replace(ref _hook, ObservableAutoWrapper.connect_item_hooks(child_algo_selectors, s => { + s.load_algo_data_recursive(algo_data, default_algo); + return Disposable.empty; + })); + } + } + + public IDisposable Subscribe(IObserver observer) => throw new NotImplementedException(); #endregion } diff --git a/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs index d3e2ab62e..f1cff6c37 100644 --- a/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/TriggerOrderVM.cs @@ -56,9 +56,6 @@ namespace mbts.spark { public bool is_timeout_checked { get => _is_timeout_checked.Value; set => _is_timeout_checked.Value = value; } public int timeout_secs { get => _timeout_secs.Value; set => _timeout_secs.Value = value; } - public SecurityMD? security_md { get; private set; } = null; - public SecurityImmutable? security => security_md?.security; - protected override void assign_to_internal(TriggerDef trigger_def) { trigger_def.TriggerAction = new TriggerAction(); if (security.HasValue) @@ -135,8 +132,7 @@ namespace mbts.spark { assert(!is_timeout_checked || timeout_secs > 0, nameof(timeout_secs), "Please specify valid Timeout(secs)."); } - void IObserver.OnNext(SecurityMD? value) { - security_md = value; + protected override void on_security_md_internal(SecurityMD? security_md) { _refresh_md(); if (double.IsNaN(fixed_price) || !_fixed_price.setter_called) { switch (trigger_price_type) { @@ -146,8 +142,6 @@ namespace mbts.spark { } } } - void IObserver.OnError(Exception error) { } - void IObserver.OnCompleted() { } } } } \ No newline at end of file diff --git a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs index e7ee50ca1..64ab2b744 100644 --- a/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs +++ b/src/client/spark/view/Spark/Utilities/OrderDataHelper.cs @@ -398,7 +398,7 @@ namespace mbts.spark.utilities { switch (def.CustomCase) { case CustomOrderDefinition.CustomOneofCase.Limit: case CustomOrderDefinition.CustomOneofCase.None: - def = new CustomOrderDefinition { Limit = new LimitOrderDefinition() }; + def = new CustomOrderDefinition { Spreader = new SpreaderOrderDefinition() }; break; case CustomOrderDefinition.CustomOneofCase.Stop: case CustomOrderDefinition.CustomOneofCase.StopLimit: