in spreader ladders, fix the loading of 'default' algo type

This commit is contained in:
John Colvin committed 2019-02-19 09:14:19 -06:00
1 parent 8888646e97
commit 60c66fb2f1
10 files changed
+71 -58

No files matched your search

@@ -63,8 +63,6 @@ namespace mbts.spark {
public IObservable<TableUpdate<AlgoTemplateData, AlgoKey>> subscribe_definition_templates(AlgoKey definition) =>
_definition_templates_demuxer.subscribe(definition);
public IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_security_definitions(IObservable<SecurityImmutable> security_source) => throw new NotImplementedException();
public async Task<AlgoData?> save_definition(AlgoData definition_data) {
if (definition_data.key.is_persisted) {
// TODO: implement update op when backend ready
@@ -38,45 +38,6 @@ namespace mbts.spark {
public IObservable<TableUpdate<AlgoTemplateData, AlgoKey>> subscribe_definition_templates(AlgoKey definition_key) =>
Observable.Return(TableUpdate<AlgoTemplateData, AlgoKey>.mk_empty(t => t.key));
public IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_security_definitions(IObservable<SecurityImmutable> security_source) {
return Observable.Create<TableUpdate<AlgoData, AlgoKey>>(o => {
TableUpdate<AlgoData, AlgoKey> last = TableUpdate<AlgoData, AlgoKey>.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<AlgoData?> 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(
@@ -17,7 +17,6 @@ namespace mbts.spark {
Task<AlgoTemplateData?> save_template(AlgoTemplateData template_data);
Task<bool> remove_definition(AlgoKey definition_key);
Task<bool> remove_template(AlgoKey template_key);
IObservable<TableUpdate<AlgoData, AlgoKey>> subscribe_security_definitions(IObservable<SecurityImmutable> security_source);
bts.config.AlgoStudioOptions ui_configuration { get; }
}
@@ -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 {
@@ -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;
@@ -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) {
@@ -11,7 +11,7 @@ using System.Threading.Tasks;
namespace mbts.spark {
static partial class OrderTypeVMFactory {
class DynamicOrderVM : OrderTypeVMBase<DynamicOrderDefinition, DynamicOrderDefinitionImmutable>, IObserver<OrdersModel> {
class DynamicOrderVM : OrderTypeVMBase<DynamicOrderDefinition, DynamicOrderDefinitionImmutable> {
readonly ObservableKeyedCollection<DynamicOrderParamVM, string> _parameters = new ObservableKeyedCollection<DynamicOrderParamVM, string>(vm => vm.descriptor.ParamName);
readonly Property<string> _dyn_type;
OrdersModel _model;
@@ -65,9 +65,7 @@ namespace mbts.spark {
_reset_dynamic_types();
}
}
void IObserver<OrdersModel>.OnCompleted() { }
void IObserver<OrdersModel>.OnError(Exception error) { }
void IObserver<OrdersModel>.OnNext(OrdersModel model) {
protected override void on_model_internal(OrdersModel model) {
_model = model;
_reset_dynamic_types();
}
@@ -132,4 +130,4 @@ namespace mbts.spark {
}
}
}
}
}
@@ -107,7 +107,7 @@ namespace mbts.spark {
}
#region OrderTypeVM Base Classes
abstract class OrderTypeVMBase<TMutable, TImmutable> : DisposableViewModelBase, IAlgoVM where TMutable : class, IMessage, new() where TImmutable : struct, IImmutableMessage {
abstract class OrderTypeVMBase<TMutable, TImmutable> : DisposableViewModelBase, IAlgoVM, IObserver<SecurityMD?>, IObserver<OrdersModel> where TMutable : class, IMessage, new() where TImmutable : struct, IImmutableMessage {
/// TODO: maybe use explicit delegates rather than rely on reflection <see cref="_descriptor"/> <see cref="_create_immutable"/>.
static readonly FieldDescriptor _descriptor = OrderTypeVMUtils.find_descriptor<TMutable>();
static readonly Func<TMutable, TImmutable> _create_immutable = OrderTypeVMUtils.immutable_factory<TMutable, TImmutable>();
@@ -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<AlgoFormats>.OnNext(OrdersModel model) {
// this.model = model;
// on_model_internal(model);
// _reset();
//}
//void IObserver<AlgoFormats>.OnError(Exception error) { }
//void IObserver<AlgoFormats>.OnCompleted() { }
// model
void IObserver<OrdersModel>.OnNext(OrdersModel model) {
this.model = model;
on_model_internal(model);
_reset();
}
void IObserver<OrdersModel>.OnError(Exception error) { }
void IObserver<OrdersModel>.OnCompleted() { }
// security md
void IObserver<SecurityMD?>.OnNext(SecurityMD? security_md) {
this.security_md = security_md;
on_security_md_internal(security_md);
_reset();
}
void IObserver<SecurityMD?>.OnError(Exception error) { }
void IObserver<SecurityMD?>.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<OrdersModel> observer) => throw new NotImplementedException();
#endregion
}
@@ -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<SecurityMD?>.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<SecurityMD?>.OnError(Exception error) { }
void IObserver<SecurityMD?>.OnCompleted() { }
}
}
}
@@ -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: