ticket/ladder order type dropdown filters items based on the security

This commit is contained in:
John Colvin committed 2018-03-01 11:18:57 -05:00
1 parent 0f9fc84085
commit 60ea25e7f9
6 files changed
+210 -123

No files matched your search

@@ -72,7 +72,7 @@ namespace mbts.ui.spark.algo
private static void SelectedItemChanged(DependencyObject d, DependencyPropertyChangedEventArgs baseValue) {
var item = ((OrderDetailsPopupControl)d).SelectedItem;
d.SetValue(HasEditablePropertiesProperty, !item.meta.NoProps);
d.SetValue(HasEditablePropertiesProperty, item != null && !item.meta.NoProps);
}
public IOrderTypeDefVM SelectedItem { get => GetValue(SelectedItemProperty) as IOrderTypeDefVM; set => SetValue(SelectedItemProperty, value); }
+25 -15
View File
@@ -4,9 +4,11 @@ using mbts.co2;
using mbts.ui;
using mbts.ui.controls;
using mbts.ui.shell;
using mbts.ui.utility;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.Linq;
using System.Reactive.Linq;
using System.Threading.Tasks;
@@ -53,22 +55,18 @@ namespace mbts.spark {
_open = backing(nameof(open), "");
_volume = backing(nameof(volume), 0ul);
_market = OrderTypeDefVMFactory.market(model.order_gateway.factory);
_limit = OrderTypeDefVMFactory.limit(model.order_gateway.factory);
_stop = OrderTypeDefVMFactory.stop(model.order_gateway.factory);
_stop_limit = OrderTypeDefVMFactory.stop_limit(model.order_gateway.factory);
_iceberg = OrderTypeDefVMFactory.iceberg(model.order_gateway.factory, model.order_gateway.spreader);
_iceberg.set_security(model.security);
_time_box = OrderTypeDefVMFactory.time_box(model.order_gateway.factory);
_spreader = OrderTypeDefVMFactory.spreader(model.order_gateway.factory, model.order_gateway.spreader);
_spreader.set_security(model.security);
// calculator
calculator = new CalculatorLogic(0, settings.Select(s => s.calculator_buttons));
// Order
order_types = OrderTypeDefVMFactory.get_collection(model.order_gateway, Observable.Return(model.security));
WPFHelper.select_first_item(order_types, new Action<IOrderTypeDefVM>(ot => {
if (!_try_select_settings_algo()) {
selected_order_type = ot;
RaisePropertyChanged(nameof(selected_order_type));
}
}));
_selected_time_in_force = backing(nameof(selected_order_type), TimeInForce.Day);
selected_order_type = _limit;
_revert = backing(nameof(revert), false);
send_order_command = new AsyncCommand<(double, Side?)>(send_order);
cancel_command = new AsyncCommand<LadderModel.CancelType>(_cancel);
@@ -78,6 +76,11 @@ namespace mbts.spark {
this.settings = settings;
_dispose = Disposable.Create(
calculator,
Disposable.Create(() => {
foreach (var ot in order_types.OfType<IDisposable>())
ot.Dispose();
order_types.Dispose();
}),
settings.Subscribe(settings_updated),
// 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
@@ -178,8 +181,6 @@ namespace mbts.spark {
#endregion
#region Orders
readonly IOrderTypeDefVM _market, _limit, _stop, _stop_limit, _time_box;
readonly ISecurityOrderTypeDefVM _iceberg, _spreader;
Property<bool> _revert;
Property<TimeInForce> _selected_time_in_force;
@@ -189,7 +190,7 @@ namespace mbts.spark {
public TimeInForce[] time_in_forces => Enum.GetValues(typeof(TimeInForce)).Cast<TimeInForce>().ToArray();
public TimeInForce selected_time_in_force { get => _selected_time_in_force.Value; set => _selected_time_in_force.Value = value; }
public IOrderTypeDefVM[] order_types => new[] { _market, _limit, _stop, _stop_limit, _iceberg, _time_box, _spreader };
public IRXCollection<IOrderTypeDefVM> order_types { get; }
public IOrderTypeDefVM selected_order_type { get; set; }
public ObservableCollection<OrderVM> orders { get; } = new ObservableCollection<OrderVM>();
public IAsyncCommand cancel_command { get; }
@@ -272,12 +273,21 @@ namespace mbts.spark {
void settings_updated(LadderSettings settings) {
if (selected_order_type == null) {
selected_order_type = order_types.FirstOrDefault(o => o.type_name == settings.SelectedAlgo) ?? order_types.First();
selected_time_in_force = (TimeInForce)Enum.Parse(typeof(TimeInForce), settings.DefaultTimeInForce);
RaisePropertyChanged(nameof(selected_order_type), nameof(selected_time_in_force));
}
if (!calculator.value.HasValue) calculator.value = settings.size;
_settings = settings;
}
bool _try_select_settings_algo() {
var algo_match = order_types.FirstOrDefault(o => o.type_name == _settings.SelectedAlgo);
if (algo_match != null) {
selected_order_type = algo_match;
RaisePropertyChanged(nameof(selected_order_type));
return true;
}
return false;
}
}
}
@@ -1,9 +1,14 @@
using bts.api;
using bts.api.orderman;
using bts.spark;
using mbts.collections.extensions;
using mbts.spark.utilities;
using mbts.ui;
using mbts.ui.shell;
using mbts.ui.utility;
using System;
using System.Linq;
using System.Reactive.Linq;
using System.Windows.Input;
namespace mbts.spark {
@@ -15,6 +20,7 @@ namespace mbts.spark {
string display_name { get; }
bool key_match(KeyEventArgs e);
}
interface ISecurityOrderTypeDefVM : IOrderTypeDefVM {
bool is_ready { get; }
void set_security(SecurityImmutable security);
@@ -25,9 +31,39 @@ namespace mbts.spark {
public static IOrderTypeDefVM limit(OrderFactory factory) => new LimitOrderVM(factory);
public static IOrderTypeDefVM stop(OrderFactory factory) => new StopOrderVM(factory);
public static IOrderTypeDefVM stop_limit(OrderFactory factory) => new StopLimitOrderVM(factory);
public static ISecurityOrderTypeDefVM iceberg(OrderFactory factory, SpreaderModel model) => new IcebergOrderVM(factory, model);
public static IOrderTypeDefVM time_box(OrderFactory factory) => new TimeBoxOrderVM(factory);
public static ISecurityOrderTypeDefVM spreader(OrderFactory factory, SpreaderModel spreader_model) => new SpreaderOrderVM(factory, spreader_model);
public static ISecurityOrderTypeDefVM iceberg(OrdersModel orders_model) => new IcebergOrderVM(orders_model);
public static ISecurityOrderTypeDefVM spreader(OrdersModel orders_model) => new SpreaderOrderVM(orders_model);
public static IRXCollection<IOrderTypeDefVM> get_collection(OrdersModel orders_model, IObservable<SecurityImmutable> security) {
var vm_factory = _vm_factory(orders_model);
return RXCollection.Create<IOrderTypeDefVM, SecurityImmutable>(security, (collection, sec) => {
var order_types = orders_model.factory.security_order_types(sec).ToList();
collection.RemoveWhere(otd => !order_types.Contains(otd.order_type));
var new_order_types = order_types.Except(collection.Select(otd => otd.order_type)).ToList();
foreach (var ot in new_order_types) {
var vm = vm_factory(ot);
if (vm != null) {
(vm as ISecurityOrderTypeDefVM)?.set_security(sec);
collection.Add(vm);
}
}
});
}
static Func<CustomOrderDefinition.CustomOneofCase, IOrderTypeDefVM> _vm_factory(OrdersModel orders_model) =>
new Func<CustomOrderDefinition.CustomOneofCase, IOrderTypeDefVM>(order_type => {
switch (order_type) {
case CustomOrderDefinition.CustomOneofCase.Market: return market(orders_model.factory);
case CustomOrderDefinition.CustomOneofCase.Limit: return limit(orders_model.factory);
case CustomOrderDefinition.CustomOneofCase.Stop: return stop(orders_model.factory);
case CustomOrderDefinition.CustomOneofCase.StopLimit: return stop_limit(orders_model.factory);
case CustomOrderDefinition.CustomOneofCase.TimeBox: return time_box(orders_model.factory);
case CustomOrderDefinition.CustomOneofCase.Iceberg: return iceberg(orders_model);
case CustomOrderDefinition.CustomOneofCase.Spreader: return spreader(orders_model);
default: return null;
}
});
#region Implentations
private abstract class OrderTypeVMBase : ViewModelBase, IOrderTypeDefVM {
@@ -114,29 +150,30 @@ namespace mbts.spark {
}
}
private class IcebergOrderVM : OrderTypeVMBase<IcebergOrderDefinition>, ISecurityOrderTypeDefVM {
readonly IOrderTypeDefVM _market, _limit, _stop, _stop_limit, _time_box, _spreader;
readonly Lazy<IOrderTypeDefVM> _iceberg;
private class IcebergOrderVM : OrderTypeVMBase<IcebergOrderDefinition>, ISecurityOrderTypeDefVM, IDisposable {
readonly OrdersModel _orders_model;
IRXCollection<IOrderTypeDefVM> _order_types;
SecurityImmutable? _security;
internal IcebergOrderVM(OrderFactory factory, SpreaderModel spreader_model) : base(factory) {
_market = market(factory);
_limit = limit(factory);
_stop = stop(factory);
_stop_limit = stop_limit(factory);
_iceberg = new Lazy<IOrderTypeDefVM>(() => {
var ovm = iceberg(factory, spreader_model);
if (_security.HasValue)
ovm.set_security(_security.Value);
return ovm;
});
_time_box = time_box(factory);
_spreader = spreader(factory, spreader_model);
child_order = _limit;
}
internal IcebergOrderVM(OrdersModel orders_model) : base(orders_model.factory) =>
_orders_model = orders_model;
event Action<SecurityImmutable> _on_security;
public double show_quantity { get; set; }
public IOrderTypeDefVM[] child_order_types => new[] { _market, _limit, _stop, _stop_limit, _iceberg.Value, _time_box, _spreader };
public IRXCollection<IOrderTypeDefVM> child_order_types {
get {
if (_order_types == null) {
var sec_src = Observable.FromEvent<SecurityImmutable>(cb => _on_security += cb, cb => _on_security -= cb);
_order_types = get_collection(_orders_model, _security.HasValue ? sec_src.StartWith(_security.Value) : sec_src);
WPFHelper.select_first_item(_order_types, new Action<IOrderTypeDefVM>(ot => {
child_order = ot;
RaisePropertyChanged(nameof(child_order));
}));
}
return _order_types;
}
}
public IOrderTypeDefVM child_order { get; set; }
public bool is_ready {
get {
@@ -160,9 +197,14 @@ namespace mbts.spark {
public void set_security(SecurityImmutable security) {
_security = security;
((ISecurityOrderTypeDefVM)_spreader).set_security(security);
if (_iceberg.IsValueCreated)
((ISecurityOrderTypeDefVM)_iceberg.Value).set_security(security);
_on_security?.Invoke(security);
}
public void Dispose() {
if (_order_types != null) {
foreach (var ot in _order_types.OfType<IDisposable>()) ot.Dispose();
_order_types.Dispose();
}
}
}
@@ -186,20 +228,19 @@ namespace mbts.spark {
}
}
private class SpreaderOrderVM : OrderTypeVMBase<SpreaderOrderDefinition>, ISecurityOrderTypeDefVM, IDisposable {
private class SpreaderOrderVM : OrderTypeVMBase<SpreaderOrderDefinition>, ISecurityOrderTypeDefVM {
SecurityImmutable? _security;
SpreaderModel _model;
IDisposable _strategy_sub;
OrdersModel _orders_model;
ExecutionStrategyImmutable? _strategy;
internal SpreaderOrderVM(OrderFactory factory, SpreaderModel spreader_model) : base(factory) =>
_model = spreader_model;
internal SpreaderOrderVM(OrdersModel orders_model) : base(orders_model.factory) =>
_orders_model = orders_model;
public bool is_ready => _security.HasValue && _strategy.HasValue;
public async void set_security(SecurityImmutable security) {
_security = security;
var lookup = await _model.lookup_strategy_async(security);
var lookup = await _orders_model.spreader.lookup_strategy_async(security);
if (lookup.success)
_strategy = lookup.result;
}
@@ -216,8 +257,6 @@ namespace mbts.spark {
// this strategy will be overwritten by strategy changes to any synthetic (due to subscription in constructor)
protected override void load_from_internal(CustomOrderDefinitionImmutable value) =>
_strategy = value.Spreader.ExecutionStrategy;
public void Dispose() => Disposable.dispose(ref _strategy_sub);
}
#endregion
}
@@ -10,10 +10,8 @@ using System.Linq;
using System.Reactive.Linq;
using System.Windows.Input;
namespace mbts.spark
{
namespace mbts.spark {
class OrderTicketVM : DisposableViewModelBase, IRequestViewClose {
readonly IOrderTypeDefVM _market, _limit, _stop, _stop_limit, _time_box, _spreader, _iceberg;
OrderDefinitionImmutable _def = OrderDataHelper.Defaults.OrderDefinitionImmutable;
uint _key;
@@ -26,74 +24,68 @@ namespace mbts.spark
.Select(tup => new OrderParams(tup.security.Value, tup.order.Def, order_key, wprice:tup.order.State.Price, wsize:tup.order.working_quantity())), settings) { }
OrderTicketVM(OrdersModel model, IObservable<OrderParams> order_params, IObservable<LadderSettings> settings) {
_market = OrderTypeDefVMFactory.market(model.factory);
_limit = OrderTypeDefVMFactory.limit(model.factory);
_stop = OrderTypeDefVMFactory.stop(model.factory);
_stop_limit = OrderTypeDefVMFactory.stop_limit(model.factory);
_iceberg = OrderTypeDefVMFactory.iceberg(model.factory, model.spreader);
_time_box = OrderTypeDefVMFactory.time_box(model.factory);
_spreader = OrderTypeDefVMFactory.spreader(model.factory, model.spreader);
accounts = model.factory.accounts;
bbo = new BBOVM(order_params.Select(o => o.smd));
size_calculator = new CalculatorLogic(null, settings.Select(s => s.calculator_buttons));
set_price_command = new DelegateCommand<double>(p => { price = p; RaisePropertyChanged(nameof(price)); });
send_order = new DelegateCommand<Side>(side => {
switch (_input_validity()) {
case InputValidity.Price: size_calculator.flash_value_error(); break;
case InputValidity.Size: flash_error(nameof(price)).ignore(); break;
case InputValidity.Both:
var mo = _def.CloneToMutable();
mo.Side = side;
selected_order_type.assign_to(mo.CustomDef);
model.send_order(new OrderDefinitionImmutable(mo), price, size_calculator.value.Value).ignore();
_raise_request_close();
break;
case InputValidity.None:
size_calculator.flash_value_error();
flash_error(nameof(price)).ignore();
break;
var vi = _validate_input();
if (vi.order_type_valid && vi.price_valid && vi.size_valid) {
var mo = _def.CloneToMutable();
mo.Side = side;
selected_order_type.assign_to(mo.CustomDef);
model.send_order(new OrderDefinitionImmutable(mo), price, size_calculator.value.Value).ignore();
_raise_request_close();
}
});
modify_order = new DelegateCommand(() => {
switch (_input_validity()) {
case InputValidity.Price: model.update_order_price(_key, price).ignore(); break;
case InputValidity.Size: model.update_order_size(_key, size_calculator.value.Value).ignore(); break;
case InputValidity.Both: model.update_order(_key, price, size_calculator.value.Value).ignore(); break;
case InputValidity.None:
default:
flash_error(nameof(price)).ignore();
size_calculator.flash_value_error();
return;
var vi = _validate_input();
if (vi.order_type_valid) {
if (vi.price_valid) {
if (vi.size_valid) {
model.update_order(_key, price, size_calculator.value.Value).ignore();
} else {
model.update_order_price(_key, price).ignore();
}
} else if (vi.size_valid) {
model.update_order_size(_key, size_calculator.value.Value).ignore();
} else return;
_raise_request_close();
}
_raise_request_close();
});
cancel_order = new DelegateCommand(() => {
model.cancel_order(_key).ignore();
_raise_request_close();
});
_dispose = Disposable.Create(order_params.ObserveOnDispatcher().Subscribe(ops => {
_def = ops.def;
_key = ops.key;
security = ops.smd.security;
foreach (var sec_order in order_types.OfType<ISecurityOrderTypeDefVM>())
sec_order.set_security(security);
if (ops.price.HasValue) price = ops.price.Value;
working_price = ops.wprice;
if (ops.size.HasValue) size_calculator.value = ops.size.Value;
working_size = ops.wsize;
account = ops.def.Account;
foreach (var ot in order_types) ot.load_from(_def.CustomDef);
switch (_def.CustomDef.CustomCase) {
case CustomOrderDefinition.CustomOneofCase.Market: selected_order_type = _market; break;
case CustomOrderDefinition.CustomOneofCase.Limit: selected_order_type = _limit; break;
case CustomOrderDefinition.CustomOneofCase.Stop: selected_order_type = _stop; break;
case CustomOrderDefinition.CustomOneofCase.StopLimit: selected_order_type = _stop_limit; break;
case CustomOrderDefinition.CustomOneofCase.Iceberg: selected_order_type = _iceberg; break;
case CustomOrderDefinition.CustomOneofCase.TimeBox: selected_order_type = _time_box; break;
default: selected_order_type = _limit; break;
}
RaisePropertyChanged(nameof(security), nameof(price), nameof(working_price), nameof(working_size), nameof(account), nameof(selected_order_type), nameof(selected_time_in_force));
}), bbo);
order_types = OrderTypeDefVMFactory.get_collection(model, order_params.Select(ops => ops.smd.security));
WPFHelper.select_first_item(order_types, new Action<IOrderTypeDefVM>(ot => {
selected_order_type = ot;
RaisePropertyChanged(nameof(selected_order_type));
}));
_dispose = Disposable.Create(bbo,
Disposable.Create(() => {
foreach (var ot in order_types.OfType<IDisposable>())
ot.Dispose();
order_types.Dispose();
}),
order_params.ObserveOnDispatcher().Subscribe(ops => {
_def = ops.def;
_key = ops.key;
security = ops.smd.security;
if (ops.price.HasValue) price = ops.price.Value;
working_price = ops.wprice;
if (ops.size.HasValue) size_calculator.value = ops.size.Value;
working_size = ops.wsize;
account = ops.def.Account;
foreach (var ot in order_types)
ot.load_from(_def.CustomDef);
var ot_match = order_types.FirstOrDefault(ot => ot.order_type == _def.CustomDef.CustomCase);
if (ot_match != null) {
selected_order_type = ot_match;
RaisePropertyChanged(nameof(selected_order_type));
}
RaisePropertyChanged(nameof(security), nameof(price), nameof(working_price), nameof(working_size), nameof(account), nameof(selected_time_in_force));
}));
}
public event EventHandler RequestClose;
@@ -114,17 +106,20 @@ namespace mbts.spark
public ICommand send_order { get; }
public ICommand modify_order { get; }
public ICommand cancel_order { get; }
public IOrderTypeDefVM[] order_types => new[] { _market, _limit, _stop, _stop_limit, _iceberg, _time_box, _spreader };
public IRXCollection<IOrderTypeDefVM> order_types { get; }
public IOrderTypeDefVM selected_order_type { get; set; }
InputValidity _input_validity() =>
_order_type_valid() ?
_price_valid() ?
_size_valid() ?
InputValidity.Both : InputValidity.Price :
_size_valid() ?
InputValidity.Size : InputValidity.None :
InputValidity.None;
(bool order_type_valid, bool price_valid, bool size_valid) _validate_input() {
(bool order_type_valid, bool price_valid, bool size_valid) rv =
(_order_type_valid(), _price_valid(), _size_valid());
if (!rv.order_type_valid)
flash_error(nameof(selected_order_type)).ignore();
if (!rv.price_valid)
flash_error(nameof(price)).ignore();
if (!rv.size_valid)
size_calculator.flash_value_error();
return rv;
}
bool _price_valid() =>
!double.IsNaN(price) && price != 0;
@@ -133,9 +128,12 @@ namespace mbts.spark
size_calculator.value.HasValue && size_calculator.value.Value != 0;
bool _order_type_valid() {
var sec_order = selected_order_type as ISecurityOrderTypeDefVM;
if (sec_order == null) return true;
return sec_order.is_ready;
if (selected_order_type == null) return false;
else {
var sec_order = selected_order_type as ISecurityOrderTypeDefVM;
if (sec_order == null) return true;
return sec_order.is_ready;
}
}
void _raise_request_close() =>
@@ -15,8 +15,20 @@ namespace mbts.spark.utilities
// OrdersModel imports and exposes OrderFactory as a public property
[Export(typeof(OrderFactory))]
class OrderFactory {
static readonly OrderMetadata _default_order_metadata = new OrderMetadata { KeyBinding = "", Color = BTSColors.pinkalicious };
static readonly CustomOrderDefinition.CustomOneofCase[]
_standard_types = new[] {
CustomOrderDefinition.CustomOneofCase.Market,
CustomOrderDefinition.CustomOneofCase.Limit,
CustomOrderDefinition.CustomOneofCase.Stop,
CustomOrderDefinition.CustomOneofCase.StopLimit,
CustomOrderDefinition.CustomOneofCase.Iceberg,
CustomOrderDefinition.CustomOneofCase.TimeBox,
}, _spreader_types = new[] {
CustomOrderDefinition.CustomOneofCase.Iceberg,
CustomOrderDefinition.CustomOneofCase.Spreader
};
readonly string _login;
static OrderMetadata _default_order_metadata = new OrderMetadata { KeyBinding = "", Color = BTSColors.pinkalicious };
[ImportingConstructor]
public OrderFactory([Import("username")]string login) {
@@ -32,18 +44,24 @@ namespace mbts.spark.utilities
Account = accounts[0],
SecurityKey = security.Id,
Side = Side.Buy,
TimeInForce = bts.api.orderman.TimeInForce.Day,
TimeInForce = TimeInForce.Day,
CustomDef = custom_order(),
CtiCode = bts.api.orderman.CTICode.CtiCode1,
CustomerOrFirm = bts.api.orderman.CustomerOrFirm.Firm,
CtiCode = CTICode.CtiCode1,
CustomerOrFirm = CustomerOrFirm.Firm,
// this will be the tag 50 on CME orders
// current user might be okay, but we might also want to get it
// from the store that serves the risk admin gui
ManualOrderIndicator = bts.api.orderman.ManualOrderIndicator.Yes
ManualOrderIndicator = ManualOrderIndicator.Yes
};
public CustomOrderDefinition custom_order() => new CustomOrderDefinition { Limit = limit_order() };
public IEnumerable<CustomOrderDefinition.CustomOneofCase> security_order_types(SecurityImmutable security) {
switch(security.ContractCase) {
case Security.ContractOneofCase.Synthetic: return _spreader_types;
default: return _standard_types;
}
}
public CustomOrderDefinition custom_order() => new CustomOrderDefinition { Limit = limit_order() };
public MarketOrderDefinition market_order() => new MarketOrderDefinition { };
public LimitOrderDefinition limit_order() => new LimitOrderDefinition { };
public StopOrderDefinition stop_order() => new StopOrderDefinition { };
@@ -1,4 +1,5 @@
using System;
using System.Collections.Generic;
using System.Collections.Specialized;
using System.Linq;
using System.Windows;
@@ -27,6 +28,27 @@ namespace mbts.ui {
}
}
public static void select_first_item<T, TSource>(TSource source, Action<T> set_selected_item) where TSource : IList<T>, INotifyCollectionChanged =>
select_first_item(source, new Func<T, bool>(item => {
set_selected_item(item);
return true;
}));
public static void select_first_item<T, TSource>(TSource source, Func<T, bool> set_selected_item) where TSource : IList<T>, INotifyCollectionChanged {
foreach (var item in source)
if (set_selected_item(item)) return;
NotifyCollectionChangedEventHandler source_changed = null;
source.CollectionChanged += source_changed = (s, e) => {
switch (e.Action) {
case NotifyCollectionChangedAction.Add:
foreach (T item in source)
if (set_selected_item(item))
source.CollectionChanged -= source_changed;
break;
}
};
}
public static RowDefinition get_element_row(Grid grid, FrameworkElement element) {
int index = Grid.GetRow(element);
var rows = grid.RowDefinitions;