From cf8faf8c4e4cbd950d85d2b413d533b2f7283ae8 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Tue, 6 Mar 2018 13:47:59 -0500 Subject: [PATCH] split up OrderTypeDefVMS into there own classes --- .../spark/Orders/ExistingOrderTicketVM.cs | 2 +- src/client/spark/Orders/IOrderTypeDefVM.cs | 502 ------------------ .../Orders/OrderModificationControl.xaml.cs | 2 +- .../spark/Orders/OrderPropertiesEditorVM.cs | 24 +- .../spark/Orders/OrderTypeVMs/IOrderTypeVM.cs | 39 ++ .../Orders/OrderTypeVMs/IcebergOrderVM.cs | 157 ++++++ .../spark/Orders/OrderTypeVMs/LimitOrderVM.cs | 13 + .../Orders/OrderTypeVMs/MarketOrderVM.cs | 13 + .../Orders/OrderTypeVMs/OrderTypeVMFactory.cs | 116 ++++ .../Orders/OrderTypeVMs/SpreaderOrderVM.cs | 53 ++ .../Orders/OrderTypeVMs/StopLimitOrderVM.cs | 57 ++ .../spark/Orders/OrderTypeVMs/StopOrderVM.cs | 57 ++ .../Orders/OrderTypeVMs/TimeBoxOrderVM.cs | 61 +++ .../Order/OrderDetailsPopupControl.xaml.cs | 14 +- 14 files changed, 587 insertions(+), 523 deletions(-) delete mode 100644 src/client/spark/Orders/IOrderTypeDefVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/IcebergOrderVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/LimitOrderVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/MarketOrderVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/StopOrderVM.cs create mode 100644 src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs diff --git a/src/client/spark/Orders/ExistingOrderTicketVM.cs b/src/client/spark/Orders/ExistingOrderTicketVM.cs index a46b6ffcb..cb77abd9e 100644 --- a/src/client/spark/Orders/ExistingOrderTicketVM.cs +++ b/src/client/spark/Orders/ExistingOrderTicketVM.cs @@ -97,6 +97,6 @@ namespace mbts.spark { protected override void _on_size_changed(uint? value) => _size_dirty.refresh(); protected override void _on_selected_account_changed(string value) => _account_dirty.refresh(); protected override void _on_selected_time_in_force_changed(TimeInForce value) => _time_in_force_dirty.refresh(); - protected override void _on_selected_order_type_changed(IOrderTypeDefVM value) => _order_type_dirty.refresh(); + protected override void _on_selected_order_type_changed(IOrderTypeVM value) => _order_type_dirty.refresh(); } } \ No newline at end of file diff --git a/src/client/spark/Orders/IOrderTypeDefVM.cs b/src/client/spark/Orders/IOrderTypeDefVM.cs deleted file mode 100644 index 6af53baa5..000000000 --- a/src/client/spark/Orders/IOrderTypeDefVM.cs +++ /dev/null @@ -1,502 +0,0 @@ -using bts.api; -using bts.api.orderman; -using bts.spark; -using mbts.spark.utilities; -using mbts.ui; -using mbts.ui.shell; -using mbts.ui.utility; -using mbts.utils; -using System; -using System.Collections.ObjectModel; -using System.Linq; -using System.Reactive.Linq; -using System.Windows.Input; -using static bts.api.orderman.CustomOrderDefinition; - -namespace mbts.spark { - interface IOrderTypeDefVM : IPropertyWrapperVM { - CustomOneofCase order_type { get; } - string type_name { get; } - bool is_bts_type { get; } - OrderMetadata meta { get; } - string display_name { get; } - bool key_match(KeyEventArgs e); - } - - // TODO: if such validation specificity is unnecessary, we should probably remove this interface - // as well as the 'is_ready' property from ISecurityOrderTypeDefVM and instead - // rely on INotifyDataErrorInfo's HasErrors property and ErrorsChanged event. - interface IParameterizedOrderTypeDefVM : IOrderTypeDefVM { - event Action parameters_valid_changed; - bool parameters_valid { get; } - } - - // TODO: maybe remove is_ready/error_message and instead rely in INotifyDataErrorInfo's HasErrors property and ErrorsChanged event. - // (see above IParameterizedOrderTypeDefVM) - interface ISecurityOrderTypeDefVM : IOrderTypeDefVM { - event Action is_ready_changed; - bool is_ready { get; } - string error_message { get; } - void set_security(SecurityImmutable security); - } - - interface ILazyOrderTypeDefVM : IOrderTypeDefVM { - bool is_initialized { get; } - void initialize(); - } - - static class OrderTypeDefVMFactory { - public static IOrderTypeDefVM market(OrderFactory factory) => new MarketOrderVM(factory); - 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 IOrderTypeDefVM time_box(OrderFactory factory) => new TimeBoxOrderVM(factory); - public static ISecurityOrderTypeDefVM iceberg(OrdersModel orders_model) => new IcebergOrderVM(orders_model); - public static ISecurityOrderTypeDefVM spreader(OrdersModel orders_model) => new SpreaderOrderVM(orders_model); - - public static ObservableAutoWrapper get_collection(OrdersModel model, ObservableCollection order_types_model, - Action on_is_ready_changed, Action on_parameters_valid_changed) { - var order_types = new ObservableAutoWrapper(order_types_model, _get_factory(model)); - foreach (var svm in order_types.OfType()) - svm.is_ready_changed += on_is_ready_changed; - foreach (var pvm in order_types.OfType()) - pvm.parameters_valid_changed += on_parameters_valid_changed; - var on_order_type_created = new Action((vm, ot) => { - if (vm is ISecurityOrderTypeDefVM svm) - svm.is_ready_changed += on_is_ready_changed; - if (vm is IParameterizedOrderTypeDefVM pvm) - pvm.parameters_valid_changed += on_parameters_valid_changed; - }); - order_types.ViewCreated += on_order_type_created; - order_types.ViewDestroyed += vm => { - if (vm is ISecurityOrderTypeDefVM svm) - svm.is_ready_changed -= on_is_ready_changed; - if (vm is IParameterizedOrderTypeDefVM pvm) - pvm.parameters_valid_changed -= on_parameters_valid_changed; - }; - return order_types; - } - - static Func _get_factory(OrdersModel orders_model) => - new Func(ot => _create(ot, orders_model)); - - static IOrderTypeDefVM _create(CustomOneofCase order_type, OrdersModel model) { - switch(order_type) { - case CustomOneofCase.Market: return market(model.factory); - case CustomOneofCase.Limit: return limit(model.factory); - case CustomOneofCase.Stop: return stop(model.factory); - case CustomOneofCase.StopLimit: return stop_limit(model.factory); - case CustomOneofCase.TimeBox: return time_box(model.factory); - case CustomOneofCase.Iceberg: return iceberg(model); - case CustomOneofCase.Spreader: return spreader(model); - default: throw new NotImplementedException(); - } - } - - #region Implentations - private abstract class OrderTypeVMBase : ViewModelBaseWithValidation, IOrderTypeDefVM { - protected readonly OrderFactory factory; - - protected OrderTypeVMBase(OrderFactory factory) => this.factory = factory; - - public abstract CustomOneofCase order_type { get; } - public abstract string type_name { get; } - public bool is_bts_type => display_name.StartsWith("BTS"); - public string display_name => OrderUtils.order_type_display_name(order_type); - public OrderMetadata meta => factory.get_metadata(order_type); - public virtual bool has_editable_properties => !meta.NoProps; - - public abstract void assign_to(CustomOrderDefinition value); - - public void load_from(CustomOrderDefinitionImmutable value) { - if (value.CustomCase == order_type) load_from_internal(value); - } - - public bool key_match(KeyEventArgs key) => - key.Key == (Key.A + display_name[0] - 'A'); - - protected virtual void load_from_internal(CustomOrderDefinitionImmutable value) { } - } - - private abstract class OrderTypeVMBase : OrderTypeVMBase where T : Google.Protobuf.IMessage, new() { - protected OrderTypeVMBase(OrderFactory factory) : base(factory) { } - - public override CustomOneofCase order_type => - OrderDataHelper.get_order_type(new T()); - - public override string type_name => new T().Descriptor.Name; - } - - private abstract class SecurityOrderTypeVMBase : OrderTypeVMBase, ISecurityOrderTypeDefVM where T : Google.Protobuf.IMessage, new() { - protected SecurityOrderTypeVMBase(OrderFactory factory) : base(factory) { } - - public event Action is_ready_changed; - - public bool is_ready => string.IsNullOrEmpty(error_message); - public virtual string error_message => string.Empty; - - public abstract void set_security(SecurityImmutable security); - - protected IDisposable _defer_invoke_is_ready_changed() { - bool was_ready = is_ready; - return Disposable.Create(() => { if (is_ready != was_ready) is_ready_changed?.Invoke(this, !was_ready, error_message); }); - } - protected void _raise_is_ready_changed() => - is_ready_changed?.Invoke(this, is_ready, error_message); - } - - private class MarketOrderVM : OrderTypeVMBase { - internal MarketOrderVM(OrderFactory factory) : base(factory) { } - - public override void assign_to(CustomOrderDefinition parent) => - parent.Market = factory.market_order(); - } - - private class LimitOrderVM : OrderTypeVMBase { - internal LimitOrderVM(OrderFactory factory) : base(factory) { } - - public override void assign_to(CustomOrderDefinition value) => - value.Limit = factory.limit_order(); - } - - private class StopOrderVM : SecurityOrderTypeVMBase, IParameterizedOrderTypeDefVM { - double _stop_price = double.NaN; - - internal StopOrderVM(OrderFactory factory) : base(factory) { } - - public event Action parameters_valid_changed; - - public bool parameters_valid => !DoubleHelper.IsNaNOrInfinity(stop_price); - - public double stop_price { - get => _stop_price; - set { - using (_defer_invoke_parameters_valid_changed()) - _stop_price = value; - } - } - - public ContractSpecificationImmutable spec { get; private set; } = - SecurityDataHelper.Defaults.ContractSpecificationImmutable; - - public override void assign_to(CustomOrderDefinition value) { - ExceptionAssert.InvalidOperation.That(parameters_valid, "Parameters invalid."); - var s = factory.stop_order(); - s.StopPrice = stop_price; - value.Stop = s; - } - - public override void set_security(SecurityImmutable security) { - spec = security.ContractSpec; - RaisePropertyChanged(nameof(spec)); - } - - protected override void load_from_internal(CustomOrderDefinitionImmutable value) { - using (_defer_invoke_parameters_valid_changed()) { - stop_price = value.Stop.StopPrice; - RaisePropertyChanged(nameof(stop_price)); - } - } - - IDisposable _defer_invoke_parameters_valid_changed() { - bool was_valid = parameters_valid; - return Disposable.Create(() => { - if (parameters_valid != was_valid) - parameters_valid_changed?.Invoke(this, !was_valid); - }); - } - } - - private class StopLimitOrderVM : SecurityOrderTypeVMBase, IParameterizedOrderTypeDefVM { - double _stop_price = double.NaN; - - internal StopLimitOrderVM(OrderFactory factory) : base(factory) { } - - public event Action parameters_valid_changed; - - public bool parameters_valid => !DoubleHelper.IsNaNOrInfinity(_stop_price); - - public double stop_price { - get => _stop_price; - set { - using (_defer_invoke_parameters_valid_changed()) - _stop_price = value; - } - } - - public ContractSpecificationImmutable spec { get; private set; } = - SecurityDataHelper.Defaults.ContractSpecificationImmutable; - - public override void assign_to(CustomOrderDefinition value) { - ExceptionAssert.InvalidOperation.That(parameters_valid, "Parameters invalid."); - var sl = factory.stop_limit_order(); - sl.StopPrice = stop_price; - value.StopLimit = sl; - } - - public override void set_security(SecurityImmutable security) { - spec = security.ContractSpec; - RaisePropertyChanged(nameof(spec)); - } - - protected override void load_from_internal(CustomOrderDefinitionImmutable value) { - using (_defer_invoke_parameters_valid_changed()) { - stop_price = value.StopLimit.StopPrice; - RaisePropertyChanged(nameof(stop_price)); - } - } - - IDisposable _defer_invoke_parameters_valid_changed() { - bool was_valid = parameters_valid; - return Disposable.Create(() => { - if (parameters_valid != was_valid) - parameters_valid_changed?.Invoke(this, !was_valid); - }); - } - } - - private class IcebergOrderVM : SecurityOrderTypeVMBase, IParameterizedOrderTypeDefVM, ILazyOrderTypeDefVM { - readonly OrdersModel _orders_model; - readonly ObservableCollection _child_order_types_model = - new ObservableCollection(EnumHelper.get_values_except(CustomOneofCase.None)); - ObservableAutoWrapper _child_order_types; - SecurityImmutable? _security; - IOrderTypeDefVM _child_order; - double _show_quantity = double.NaN; - - internal IcebergOrderVM(OrdersModel orders_model) : base(orders_model.factory) => - _orders_model = orders_model; - - public event Action parameters_valid_changed; - - public bool parameters_valid { - get { - if (DoubleHelper.IsNaNOrInfinityOr(_show_quantity, 0)) return false; - if (_child_order == null) return false; - if (_child_order is IParameterizedOrderTypeDefVM pvm) return pvm.parameters_valid; - return child_order_types.Contains(_child_order); - } - } - - public override string error_message { - get { - if (child_order == null) return "no child order selected"; - else if (child_order is IParameterizedOrderTypeDefVM pvm && !pvm.parameters_valid) return "child parameters invalid"; - return (child_order as ISecurityOrderTypeDefVM)?.error_message ?? string.Empty; - } - } - - public bool is_initialized => _child_order_types != null; - - public IOrderTypeDefVM child_order { - get => _child_order; - set { - using (_defer_invoke_is_ready_changed()) { - if (!is_initialized) initialize(); - if ((value is ILazyOrderTypeDefVM lvm) && !lvm.is_initialized) lvm.initialize(); - _child_order = value; - RaisePropertyChanged(); - } - } - } - - public ObservableCollection child_order_types { - get { - if (!is_initialized) initialize(); - return _child_order_types; - } - } - - public double show_quantity { - get => _show_quantity; - set { - using (_defer_invoke_parameters_valid_changed()) - _show_quantity = value; - } - } - - public override void assign_to(CustomOrderDefinition value) { - var i = factory.iceberg_order(); - i.ShowQuantity = show_quantity; - child_order.assign_to(i.Child); - value.Iceberg = i; - } - - public override void set_security(SecurityImmutable security) { - using (_defer_invoke_is_ready_changed()) { - _security = security; - _child_order_types_model.sync_with(factory.default_order_types(security)); - if (_child_order_types != null) { - foreach (var ot in _child_order_types.OfType()) - ot.set_security(_security.Value); - _select_child_order_if_invalid(); - } - } - } - - public void initialize() { - if (_child_order_types == null) { - _child_order_types = get_collection(_orders_model, _child_order_types_model, _on_child_order_is_ready_changed, _on_child_order_parameters_valid_changed); - foreach (var ot in _child_order_types.OfType()) - ot.set_security(_security.Value); - _select_child_order_if_invalid(); - } - } - - protected override void load_from_internal(CustomOrderDefinitionImmutable value) { - using (_defer_invoke_is_ready_changed()) - using (_defer_invoke_parameters_valid_changed()) { - show_quantity = value.Iceberg.ShowQuantity; - child_order = _child_order_types.FirstOrDefault(ot => ot.order_type == value.CustomCase); - RaisePropertyChanged(nameof(show_quantity), nameof(child_order)); - } - } - - void _select_child_order_if_invalid() { - if (_child_order_types.Count > 0 && (child_order == null || !_child_order_types.Contains(child_order))) { - var ot = _orders_model.factory.default_order_type(_security, true); - var child = _child_order_types.FirstOrDefault(vm => vm.order_type == CustomOneofCase.Limit); - // do not select an ILazyOrderTypeDefVM child by default, this will cause a stack overflow - if (child == null || child is ILazyOrderTypeDefVM) - child = _child_order_types.FirstOrDefault(vm => !(vm is ILazyOrderTypeDefVM)); - if (child != null) { - child_order = child; - RaisePropertyChanged(nameof(child_order)); - } - } - } - - void _validate_selected_order_type() { - using (validation(nameof(child_order))) { - var svm = _child_order as ISecurityOrderTypeDefVM; - var pvm = _child_order as IParameterizedOrderTypeDefVM; - validation_assert( - _child_order != null && _child_order_types.Contains(_child_order) && (svm == null || svm.is_ready), - svm?.error_message ?? string.Empty, nameof(child_order) - ); - } - } - - void _on_child_order_is_ready_changed(ISecurityOrderTypeDefVM sender, bool is_ready, string error_message) { - if (sender == _child_order) { - _validate_selected_order_type(); - _raise_is_ready_changed(); - } - } - - void _on_child_order_parameters_valid_changed(IParameterizedOrderTypeDefVM sender, bool parameters_valid) { - if (sender == _child_order) { - using (_defer_invoke_parameters_valid_changed()) - _validate_selected_order_type(); - } - } - - IDisposable _defer_invoke_parameters_valid_changed() { - bool was_valid = parameters_valid; - return Disposable.Create(() => { - if (parameters_valid != was_valid) - parameters_valid_changed?.Invoke(this, !was_valid); - }); - } - } - - private class TimeBoxOrderVM : OrderTypeVMBase, IParameterizedOrderTypeDefVM { - TimeTextTuple _start = TimeTextTuple.FromDateTime(DateTime.Now), _stop = TimeTextTuple.FromDateTime(DateTime.Now.AddMinutes(5)); - - internal TimeBoxOrderVM(OrderFactory factory) : base(factory) { } - - public event Action parameters_valid_changed; - - public bool parameters_valid => _start.result.HasValue && _stop.result.HasValue; - - public TimeTextTuple start { - get => _start; - set { - using (_defer_invoke_parameters_valid_changed()) - using (validation(nameof(start))) - validation_assert((_start = value).result.HasValue, string.Empty, nameof(start)); - } - } - public TimeTextTuple stop { - get => _stop; - set { - using (_defer_invoke_parameters_valid_changed()) - using (validation(nameof(stop))) - validation_assert((_stop = value).result.HasValue, string.Empty, nameof(stop)); - } - } - - public override void assign_to(CustomOrderDefinition value) { - DateTime? start_result = start.result, stop_result = stop.result; - ExceptionAssert.InvalidOperation.That(start_result.HasValue && stop_result.HasValue, "TimeBoxOrderVm parameters are invalid."); - var tb = factory.time_box_order(); - tb.Start = start.result.Value.ToUniversalTime().ToGoogleTime(); - tb.Stop = stop.result.Value.ToUniversalTime().ToGoogleTime(); - value.TimeBox = tb; - } - - protected override void load_from_internal(CustomOrderDefinitionImmutable value) { - using (_defer_invoke_parameters_valid_changed()) { - start = TimeTextTuple.FromDateTime(value.TimeBox.Start.ToDateTime().ToLocalTime()); - stop = TimeTextTuple.FromDateTime(value.TimeBox.Stop.ToDateTime().ToLocalTime()); - RaisePropertyChanged(nameof(start), nameof(stop)); - } - } - - IDisposable _defer_invoke_parameters_valid_changed() { - bool was_valid = parameters_valid; - return Disposable.Create(() => { - if (parameters_valid != was_valid) - parameters_valid_changed?.Invoke(this, !was_valid); - }); - } - } - - private class SpreaderOrderVM : SecurityOrderTypeVMBase { - SecurityImmutable? _security; - OrdersModel _orders_model; - ExecutionStrategyImmutable? _strategy; - SyntheticEditorVM _strategy_editor; - - internal SpreaderOrderVM(OrdersModel orders_model) : base(orders_model.factory) => - _orders_model = orders_model; - - public SyntheticEditorVM strategy_editor { - get { - if (_strategy_editor == null && _security.HasValue && _strategy.HasValue) - _strategy_editor = new SyntheticEditorVM(_orders_model.spreader, _security.Value, _strategy.Value); - return _strategy_editor; - } - } - - public override bool has_editable_properties => - base.has_editable_properties && _security.HasValue && _strategy.HasValue; - - public override string error_message => - _security.HasValue && _strategy.HasValue ? string.Empty : "waiting for strategy"; - - public override async void set_security(SecurityImmutable security) { - using (_defer_invoke_is_ready_changed()) { - _security = security; - var lookup = await _orders_model.spreader.lookup_strategy_async(security); - if (lookup.success) _strategy = lookup.result; - RaisePropertyChanged(nameof(has_editable_properties)); - } - } - - public override void assign_to(CustomOrderDefinition value) { - if (is_ready) { - var s = factory.spreader_order(); - s.ExecutionStrategy = (_strategy_editor != null ? _strategy_editor.create_strategy() : _strategy.Value).CloneToMutable(); - s.Security = _security.Value.CloneToMutable(); - value.Spreader = s; - } - } - - // 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; - } - #endregion - } -} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderModificationControl.xaml.cs b/src/client/spark/Orders/OrderModificationControl.xaml.cs index 8000a9055..0e6f61c46 100644 --- a/src/client/spark/Orders/OrderModificationControl.xaml.cs +++ b/src/client/spark/Orders/OrderModificationControl.xaml.cs @@ -27,7 +27,7 @@ namespace mbts.ui.spark { public DataTemplate ReflectionTemplate { get; set; } public override DataTemplate SelectTemplate(object item, DependencyObject container) { - var vm = item as IOrderTypeDefVM; + var vm = item as IOrderTypeVM; if (vm != null) { switch (vm.order_type) { case CustomOrderDefinition.CustomOneofCase.Stop: return StopMarketOrderTemplate; diff --git a/src/client/spark/Orders/OrderPropertiesEditorVM.cs b/src/client/spark/Orders/OrderPropertiesEditorVM.cs index dd4bb7270..c06a4ac45 100644 --- a/src/client/spark/Orders/OrderPropertiesEditorVM.cs +++ b/src/client/spark/Orders/OrderPropertiesEditorVM.cs @@ -35,7 +35,7 @@ namespace mbts.spark { double _price = double.NaN; string _selected_account; TimeInForce _selected_time_in_force = TimeInForce.Undefined; - IOrderTypeDefVM _selected_order_type; + IOrderTypeVM _selected_order_type; protected OrderPropertiesEditorVM(OrdersModel model, IObservable security_source, IObservable settings) : this(model, security_source, settings.Select(s => new InlineOrderProperties( @@ -47,7 +47,7 @@ namespace mbts.spark { protected OrderPropertiesEditorVM(OrdersModel model, IObservable security_source, IObservable order_properties, IObservable calcuator_buttons) { _model = model; accounts = model.factory.accounts; - order_types = OrderTypeDefVMFactory.get_collection(model, _order_types_model, _on_order_type_is_ready_changed, _on_parameters_valid_changed); + order_types = OrderTypeVMFactory.get_collection(model, _order_types_model, _on_order_type_is_ready_changed, _on_parameters_valid_changed); set_price_command = new DelegateCommand(p => { price = p; RaisePropertyChanged(nameof(price)); @@ -60,12 +60,12 @@ namespace mbts.spark { using (detect_property_changes()) { security = s; _order_types_model.sync_with(model.factory.default_order_types(security)); - foreach (var vm in order_types.OfType()) + foreach (var vm in order_types.OfType()) vm.set_security(s); security_changed?.Invoke(s); if (props.order_type_def.has_value) { if (props.order_type_def.force_override || selected_order_type == null || !order_types.Contains(selected_order_type)) { - if (order_types.TryGetFirst(ot => ot.order_type == props.order_type_def.value.CustomCase, out IOrderTypeDefVM match)) { + if (order_types.TryGetFirst(ot => ot.order_type == props.order_type_def.value.CustomCase, out IOrderTypeVM match)) { match.load_from(props.order_type_def.value); selected_order_type = match; } @@ -105,7 +105,7 @@ namespace mbts.spark { } if (props.order_type_def.has_value) { if (props.order_type_def.force_override || selected_order_type == null || !order_types.Contains(selected_order_type)) { - if (order_types.TryGetFirst(ot => ot.order_type == props.order_type_def.value.CustomCase, out IOrderTypeDefVM match)) { + if (order_types.TryGetFirst(ot => ot.order_type == props.order_type_def.value.CustomCase, out IOrderTypeVM match)) { match.load_from(props.order_type_def.value); selected_order_type = match; } @@ -125,8 +125,8 @@ namespace mbts.spark { public string selected_account { get => _selected_account; set => _on_selected_account_changed(_selected_account = value); } public ObservableCollection time_in_forces { get; } = new ObservableCollection(); public TimeInForce selected_time_in_force { get => _selected_time_in_force; set { _on_selected_time_in_force_changed(_selected_time_in_force = value); _validate_selected_time_in_force(); } } - public ObservableAutoWrapper order_types { get; } - public IOrderTypeDefVM selected_order_type { + public ObservableAutoWrapper order_types { get; } + public IOrderTypeVM selected_order_type { get => _selected_order_type; set { if ((value is ILazyOrderTypeDefVM lvm) && !lvm.is_initialized) @@ -161,7 +161,7 @@ namespace mbts.spark { protected virtual void _on_size_changed(uint? value) { } protected virtual void _on_selected_account_changed(string value) { } protected virtual void _on_selected_time_in_force_changed(TimeInForce value) { } - protected virtual void _on_selected_order_type_changed(IOrderTypeDefVM value) { } + protected virtual void _on_selected_order_type_changed(IOrderTypeVM value) { } protected void _validate_selected_account() { using (validation(nameof(selected_account))) @@ -175,8 +175,8 @@ namespace mbts.spark { protected void _validate_selected_order_type() { using (validation(nameof(selected_order_type))) { - var svm = _selected_order_type as ISecurityOrderTypeDefVM; - var pvm = _selected_order_type as IParameterizedOrderTypeDefVM; + var svm = _selected_order_type as ISecurityOrderTypeVM; + var pvm = _selected_order_type as IParameterizedOrderTypeVM; validation_assert( _selected_order_type != null && order_types.Contains(_selected_order_type) && @@ -187,12 +187,12 @@ namespace mbts.spark { } } - void _on_order_type_is_ready_changed(ISecurityOrderTypeDefVM sender, bool is_ready, string error_message) { + void _on_order_type_is_ready_changed(ISecurityOrderTypeVM sender, bool is_ready, string error_message) { if (sender == _selected_order_type) _validate_selected_order_type(); } - void _on_parameters_valid_changed(IParameterizedOrderTypeDefVM sender, bool parameters_valid) { + void _on_parameters_valid_changed(IParameterizedOrderTypeVM sender, bool parameters_valid) { if (sender == _selected_order_type) _validate_selected_order_type(); } diff --git a/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs b/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs new file mode 100644 index 000000000..8d0963c5e --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/IOrderTypeVM.cs @@ -0,0 +1,39 @@ +using bts.api; +using bts.api.orderman; +using bts.spark; +using System; +using System.Windows.Input; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark { + interface IOrderTypeVM : IPropertyWrapperVM { + CustomOneofCase order_type { get; } + string type_name { get; } + bool is_bts_type { get; } + OrderMetadata meta { get; } + string display_name { get; } + bool key_match(KeyEventArgs e); + } + + // TODO: if such validation specificity is unnecessary, we should probably remove this interface + // as well as the 'is_ready' property from ISecurityOrderTypeDefVM and instead + // rely on INotifyDataErrorInfo's HasErrors property and ErrorsChanged event. + interface IParameterizedOrderTypeVM : IOrderTypeVM { + event Action parameters_valid_changed; + bool parameters_valid { get; } + } + + // TODO: maybe remove is_ready/error_message and instead rely in INotifyDataErrorInfo's HasErrors property and ErrorsChanged event. + // (see above IParameterizedOrderTypeDefVM) + interface ISecurityOrderTypeVM : IOrderTypeVM { + event Action is_ready_changed; + bool is_ready { get; } + string error_message { get; } + void set_security(SecurityImmutable security); + } + + interface ILazyOrderTypeDefVM : IOrderTypeVM { + bool is_initialized { get; } + void initialize(); + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/IcebergOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/IcebergOrderVM.cs new file mode 100644 index 000000000..b4af1aa2c --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/IcebergOrderVM.cs @@ -0,0 +1,157 @@ +using bts.api; +using bts.api.orderman; +using mbts.ui.utility; +using System; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.Linq; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark { + static partial class OrderTypeVMFactory { + private class IcebergOrderVM : SecurityOrderTypeVMBase, IParameterizedOrderTypeVM, ILazyOrderTypeDefVM { + readonly OrdersModel _orders_model; + readonly ObservableCollection _child_order_types_model = + new ObservableCollection(EnumHelper.get_values_except(CustomOneofCase.None)); + ObservableAutoWrapper _child_order_types; + SecurityImmutable? _security; + IOrderTypeVM _child_order; + double _show_quantity = double.NaN; + + internal IcebergOrderVM(OrdersModel orders_model) : base(orders_model.factory) => + _orders_model = orders_model; + + public event Action parameters_valid_changed; + + public bool parameters_valid { + get { + if (DoubleHelper.IsNaNOrInfinityOr(_show_quantity, 0)) return false; + if (_child_order == null) return false; + if (_child_order is IParameterizedOrderTypeVM pvm) return pvm.parameters_valid; + return child_order_types.Contains(_child_order); + } + } + + public override string error_message { + get { + if (child_order == null) return "no child order selected"; + else if (child_order is IParameterizedOrderTypeVM pvm && !pvm.parameters_valid) return "child parameters invalid"; + return (child_order as ISecurityOrderTypeVM)?.error_message ?? string.Empty; + } + } + + public bool is_initialized => _child_order_types != null; + + public IOrderTypeVM child_order { + get => _child_order; + set { + using (_defer_invoke_is_ready_changed()) { + if (!is_initialized) initialize(); + if ((value is ILazyOrderTypeDefVM lvm) && !lvm.is_initialized) lvm.initialize(); + _child_order = value; + RaisePropertyChanged(); + } + } + } + + public ObservableCollection child_order_types { + get { + if (!is_initialized) initialize(); + return _child_order_types; + } + } + + public double show_quantity { + get => _show_quantity; + set { + using (_defer_invoke_parameters_valid_changed()) + _show_quantity = value; + } + } + + public override void assign_to(CustomOrderDefinition value) { + var i = factory.iceberg_order(); + i.ShowQuantity = show_quantity; + child_order.assign_to(i.Child); + value.Iceberg = i; + } + + public override void set_security(SecurityImmutable security) { + using (_defer_invoke_is_ready_changed()) { + _security = security; + _child_order_types_model.sync_with(factory.default_order_types(security)); + if (_child_order_types != null) { + foreach (var ot in _child_order_types.OfType()) + ot.set_security(_security.Value); + _select_child_order_if_invalid(); + } + } + } + + public void initialize() { + if (_child_order_types == null) { + _child_order_types = get_collection(_orders_model, _child_order_types_model, _on_child_order_is_ready_changed, _on_child_order_parameters_valid_changed); + foreach (var ot in _child_order_types.OfType()) + ot.set_security(_security.Value); + _select_child_order_if_invalid(); + } + } + + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + using (_defer_invoke_is_ready_changed()) + using (_defer_invoke_parameters_valid_changed()) { + show_quantity = value.Iceberg.ShowQuantity; + child_order = _child_order_types.FirstOrDefault(ot => ot.order_type == value.CustomCase); + RaisePropertyChanged(nameof(show_quantity), nameof(child_order)); + } + } + + void _select_child_order_if_invalid() { + if (_child_order_types.Count > 0 && (child_order == null || !_child_order_types.Contains(child_order))) { + var ot = _orders_model.factory.default_order_type(_security, true); + var child = _child_order_types.FirstOrDefault(vm => vm.order_type == CustomOneofCase.Limit); + // do not select an ILazyOrderTypeDefVM child by default, this will cause a stack overflow + if (child == null || child is ILazyOrderTypeDefVM) + child = _child_order_types.FirstOrDefault(vm => !(vm is ILazyOrderTypeDefVM)); + if (child != null) { + child_order = child; + RaisePropertyChanged(nameof(child_order)); + } + } + } + + void _validate_selected_order_type() { + using (validation(nameof(child_order))) { + var svm = _child_order as ISecurityOrderTypeVM; + var pvm = _child_order as IParameterizedOrderTypeVM; + validation_assert( + _child_order != null && _child_order_types.Contains(_child_order) && (svm == null || svm.is_ready), + svm?.error_message ?? string.Empty, nameof(child_order) + ); + } + } + + void _on_child_order_is_ready_changed(ISecurityOrderTypeVM sender, bool is_ready, string error_message) { + if (sender == _child_order) { + _validate_selected_order_type(); + _raise_is_ready_changed(); + } + } + + void _on_child_order_parameters_valid_changed(IParameterizedOrderTypeVM sender, bool parameters_valid) { + if (sender == _child_order) { + using (_defer_invoke_parameters_valid_changed()) + _validate_selected_order_type(); + } + } + + IDisposable _defer_invoke_parameters_valid_changed() { + bool was_valid = parameters_valid; + return Disposable.Create(() => { + if (parameters_valid != was_valid) + parameters_valid_changed?.Invoke(this, !was_valid); + }); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/LimitOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/LimitOrderVM.cs new file mode 100644 index 000000000..ce5da65e6 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/LimitOrderVM.cs @@ -0,0 +1,13 @@ +using bts.api.orderman; +using mbts.spark.utilities; + +namespace mbts.spark { + static partial class OrderTypeVMFactory { + private class LimitOrderVM : OrderTypeVMBase { + internal LimitOrderVM(OrderFactory factory) : base(factory) { } + + public override void assign_to(CustomOrderDefinition value) => + value.Limit = factory.limit_order(); + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/MarketOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/MarketOrderVM.cs new file mode 100644 index 000000000..a832428a8 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/MarketOrderVM.cs @@ -0,0 +1,13 @@ +using bts.api.orderman; +using mbts.spark.utilities; + +namespace mbts.spark { + static partial class OrderTypeVMFactory { + private class MarketOrderVM : OrderTypeVMBase { + internal MarketOrderVM(OrderFactory factory) : base(factory) { } + + public override void assign_to(CustomOrderDefinition parent) => + parent.Market = factory.market_order(); + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs new file mode 100644 index 000000000..cd88f587b --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/OrderTypeVMFactory.cs @@ -0,0 +1,116 @@ +using bts.api; +using bts.api.orderman; +using bts.spark; +using mbts.spark.utilities; +using mbts.ui.shell; +using mbts.ui.utility; +using System; +using System.Collections.ObjectModel; +using System.Linq; +using System.Reactive.Linq; +using System.Windows.Input; +using static bts.api.orderman.CustomOrderDefinition; + +namespace mbts.spark { + static partial class OrderTypeVMFactory { + public static IOrderTypeVM market(OrderFactory factory) => new MarketOrderVM(factory); + public static IOrderTypeVM limit(OrderFactory factory) => new LimitOrderVM(factory); + public static IOrderTypeVM stop(OrderFactory factory) => new StopOrderVM(factory); + public static IOrderTypeVM stop_limit(OrderFactory factory) => new StopLimitOrderVM(factory); + public static IOrderTypeVM time_box(OrderFactory factory) => new TimeBoxOrderVM(factory); + public static ISecurityOrderTypeVM iceberg(OrdersModel orders_model) => new IcebergOrderVM(orders_model); + public static ISecurityOrderTypeVM spreader(OrdersModel orders_model) => new SpreaderOrderVM(orders_model); + + public static ObservableAutoWrapper get_collection(OrdersModel model, ObservableCollection order_types_model, + Action on_is_ready_changed, Action on_parameters_valid_changed) { + var order_types = new ObservableAutoWrapper(order_types_model, _get_factory(model)); + foreach (var svm in order_types.OfType()) + svm.is_ready_changed += on_is_ready_changed; + foreach (var pvm in order_types.OfType()) + pvm.parameters_valid_changed += on_parameters_valid_changed; + var on_order_type_created = new Action((vm, ot) => { + if (vm is ISecurityOrderTypeVM svm) + svm.is_ready_changed += on_is_ready_changed; + if (vm is IParameterizedOrderTypeVM pvm) + pvm.parameters_valid_changed += on_parameters_valid_changed; + }); + order_types.ViewCreated += on_order_type_created; + order_types.ViewDestroyed += vm => { + if (vm is ISecurityOrderTypeVM svm) + svm.is_ready_changed -= on_is_ready_changed; + if (vm is IParameterizedOrderTypeVM pvm) + pvm.parameters_valid_changed -= on_parameters_valid_changed; + }; + return order_types; + } + + static Func _get_factory(OrdersModel orders_model) => + new Func(ot => _create(ot, orders_model)); + + static IOrderTypeVM _create(CustomOneofCase order_type, OrdersModel model) { + switch (order_type) { + case CustomOneofCase.Market: return market(model.factory); + case CustomOneofCase.Limit: return limit(model.factory); + case CustomOneofCase.Stop: return stop(model.factory); + case CustomOneofCase.StopLimit: return stop_limit(model.factory); + case CustomOneofCase.TimeBox: return time_box(model.factory); + case CustomOneofCase.Iceberg: return iceberg(model); + case CustomOneofCase.Spreader: return spreader(model); + default: throw new NotImplementedException(); + } + } + + #region OrderTypeVM Base Classes + private abstract class OrderTypeVMBase : ViewModelBaseWithValidation, IOrderTypeVM { + protected readonly OrderFactory factory; + + protected OrderTypeVMBase(OrderFactory factory) => this.factory = factory; + + public abstract CustomOneofCase order_type { get; } + public abstract string type_name { get; } + public bool is_bts_type => display_name.StartsWith("BTS"); + public string display_name => OrderUtils.order_type_display_name(order_type); + public OrderMetadata meta => factory.get_metadata(order_type); + public virtual bool has_editable_properties => !meta.NoProps; + + public abstract void assign_to(CustomOrderDefinition value); + + public void load_from(CustomOrderDefinitionImmutable value) { + if (value.CustomCase == order_type) load_from_internal(value); + } + + public bool key_match(KeyEventArgs key) => + key.Key == (Key.A + display_name[0] - 'A'); + + protected virtual void load_from_internal(CustomOrderDefinitionImmutable value) { } + } + + private abstract class OrderTypeVMBase : OrderTypeVMBase where T : Google.Protobuf.IMessage, new() { + protected OrderTypeVMBase(OrderFactory factory) : base(factory) { } + + public override CustomOneofCase order_type => + OrderDataHelper.get_order_type(new T()); + + public override string type_name => new T().Descriptor.Name; + } + + private abstract class SecurityOrderTypeVMBase : OrderTypeVMBase, ISecurityOrderTypeVM where T : Google.Protobuf.IMessage, new() { + protected SecurityOrderTypeVMBase(OrderFactory factory) : base(factory) { } + + public event Action is_ready_changed; + + public bool is_ready => string.IsNullOrEmpty(error_message); + public virtual string error_message => string.Empty; + + public abstract void set_security(SecurityImmutable security); + + protected IDisposable _defer_invoke_is_ready_changed() { + bool was_ready = is_ready; + return Disposable.Create(() => { if (is_ready != was_ready) is_ready_changed?.Invoke(this, !was_ready, error_message); }); + } + protected void _raise_is_ready_changed() => + is_ready_changed?.Invoke(this, is_ready, error_message); + } + #endregion + } +} diff --git a/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs new file mode 100644 index 000000000..39920fcb2 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/SpreaderOrderVM.cs @@ -0,0 +1,53 @@ +using bts.api; +using bts.api.orderman; +using bts.spark; + +namespace mbts.spark { + static partial class OrderTypeVMFactory { + private class SpreaderOrderVM : SecurityOrderTypeVMBase { + SecurityImmutable? _security; + OrdersModel _orders_model; + ExecutionStrategyImmutable? _strategy; + SyntheticEditorVM _strategy_editor; + + internal SpreaderOrderVM(OrdersModel orders_model) : base(orders_model.factory) => + _orders_model = orders_model; + + public SyntheticEditorVM strategy_editor { + get { + if (_strategy_editor == null && _security.HasValue && _strategy.HasValue) + _strategy_editor = new SyntheticEditorVM(_orders_model.spreader, _security.Value, _strategy.Value); + return _strategy_editor; + } + } + + public override bool has_editable_properties => + base.has_editable_properties && _security.HasValue && _strategy.HasValue; + + public override string error_message => + _security.HasValue && _strategy.HasValue ? string.Empty : "waiting for strategy"; + + public override async void set_security(SecurityImmutable security) { + using (_defer_invoke_is_ready_changed()) { + _security = security; + var lookup = await _orders_model.spreader.lookup_strategy_async(security); + if (lookup.success) _strategy = lookup.result; + RaisePropertyChanged(nameof(has_editable_properties)); + } + } + + public override void assign_to(CustomOrderDefinition value) { + if (is_ready) { + var s = factory.spreader_order(); + s.ExecutionStrategy = (_strategy_editor != null ? _strategy_editor.create_strategy() : _strategy.Value).CloneToMutable(); + s.Security = _security.Value.CloneToMutable(); + value.Spreader = s; + } + } + + // 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; + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs new file mode 100644 index 000000000..fe69d9393 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/StopLimitOrderVM.cs @@ -0,0 +1,57 @@ +using bts.api; +using bts.api.orderman; +using mbts.spark.utilities; +using mbts.utils; +using System; + +namespace mbts.spark { + static partial class OrderTypeVMFactory { + private class StopLimitOrderVM : SecurityOrderTypeVMBase, IParameterizedOrderTypeVM { + double _stop_price = double.NaN; + + internal StopLimitOrderVM(OrderFactory factory) : base(factory) { } + + public event Action parameters_valid_changed; + + public bool parameters_valid => !DoubleHelper.IsNaNOrInfinity(_stop_price); + + public double stop_price { + get => _stop_price; + set { + using (_defer_invoke_parameters_valid_changed()) + _stop_price = value; + } + } + + public ContractSpecificationImmutable spec { get; private set; } = + SecurityDataHelper.Defaults.ContractSpecificationImmutable; + + public override void assign_to(CustomOrderDefinition value) { + ExceptionAssert.InvalidOperation.That(parameters_valid, "Parameters invalid."); + var sl = factory.stop_limit_order(); + sl.StopPrice = stop_price; + value.StopLimit = sl; + } + + public override void set_security(SecurityImmutable security) { + spec = security.ContractSpec; + RaisePropertyChanged(nameof(spec)); + } + + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + using (_defer_invoke_parameters_valid_changed()) { + stop_price = value.StopLimit.StopPrice; + RaisePropertyChanged(nameof(stop_price)); + } + } + + IDisposable _defer_invoke_parameters_valid_changed() { + bool was_valid = parameters_valid; + return Disposable.Create(() => { + if (parameters_valid != was_valid) + parameters_valid_changed?.Invoke(this, !was_valid); + }); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/StopOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/StopOrderVM.cs new file mode 100644 index 000000000..97fea0226 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/StopOrderVM.cs @@ -0,0 +1,57 @@ +using bts.api; +using bts.api.orderman; +using mbts.spark.utilities; +using mbts.utils; +using System; + +namespace mbts.spark { + static partial class OrderTypeVMFactory { + private class StopOrderVM : SecurityOrderTypeVMBase, IParameterizedOrderTypeVM { + double _stop_price = double.NaN; + + internal StopOrderVM(OrderFactory factory) : base(factory) { } + + public event Action parameters_valid_changed; + + public bool parameters_valid => !DoubleHelper.IsNaNOrInfinity(stop_price); + + public double stop_price { + get => _stop_price; + set { + using (_defer_invoke_parameters_valid_changed()) + _stop_price = value; + } + } + + public ContractSpecificationImmutable spec { get; private set; } = + SecurityDataHelper.Defaults.ContractSpecificationImmutable; + + public override void assign_to(CustomOrderDefinition value) { + ExceptionAssert.InvalidOperation.That(parameters_valid, "Parameters invalid."); + var s = factory.stop_order(); + s.StopPrice = stop_price; + value.Stop = s; + } + + public override void set_security(SecurityImmutable security) { + spec = security.ContractSpec; + RaisePropertyChanged(nameof(spec)); + } + + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + using (_defer_invoke_parameters_valid_changed()) { + stop_price = value.Stop.StopPrice; + RaisePropertyChanged(nameof(stop_price)); + } + } + + IDisposable _defer_invoke_parameters_valid_changed() { + bool was_valid = parameters_valid; + return Disposable.Create(() => { + if (parameters_valid != was_valid) + parameters_valid_changed?.Invoke(this, !was_valid); + }); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs new file mode 100644 index 000000000..f5469d070 --- /dev/null +++ b/src/client/spark/Orders/OrderTypeVMs/TimeBoxOrderVM.cs @@ -0,0 +1,61 @@ +using bts.api.orderman; +using mbts.spark.utilities; +using mbts.ui; +using mbts.utils; +using System; + +namespace mbts.spark { + static partial class OrderTypeVMFactory { + private class TimeBoxOrderVM : OrderTypeVMBase, IParameterizedOrderTypeVM { + TimeTextTuple _start = TimeTextTuple.FromDateTime(DateTime.Now), _stop = TimeTextTuple.FromDateTime(DateTime.Now.AddMinutes(5)); + + internal TimeBoxOrderVM(OrderFactory factory) : base(factory) { } + + public event Action parameters_valid_changed; + + public bool parameters_valid => _start.result.HasValue && _stop.result.HasValue; + + public TimeTextTuple start { + get => _start; + set { + using (_defer_invoke_parameters_valid_changed()) + using (validation(nameof(start))) + validation_assert((_start = value).result.HasValue, string.Empty, nameof(start)); + } + } + public TimeTextTuple stop { + get => _stop; + set { + using (_defer_invoke_parameters_valid_changed()) + using (validation(nameof(stop))) + validation_assert((_stop = value).result.HasValue, string.Empty, nameof(stop)); + } + } + + public override void assign_to(CustomOrderDefinition value) { + DateTime? start_result = start.result, stop_result = stop.result; + ExceptionAssert.InvalidOperation.That(start_result.HasValue && stop_result.HasValue, "TimeBoxOrderVm parameters are invalid."); + var tb = factory.time_box_order(); + tb.Start = start.result.Value.ToUniversalTime().ToGoogleTime(); + tb.Stop = stop.result.Value.ToUniversalTime().ToGoogleTime(); + value.TimeBox = tb; + } + + protected override void load_from_internal(CustomOrderDefinitionImmutable value) { + using (_defer_invoke_parameters_valid_changed()) { + start = TimeTextTuple.FromDateTime(value.TimeBox.Start.ToDateTime().ToLocalTime()); + stop = TimeTextTuple.FromDateTime(value.TimeBox.Stop.ToDateTime().ToLocalTime()); + RaisePropertyChanged(nameof(start), nameof(stop)); + } + } + + IDisposable _defer_invoke_parameters_valid_changed() { + bool was_valid = parameters_valid; + return Disposable.Create(() => { + if (parameters_valid != was_valid) + parameters_valid_changed?.Invoke(this, !was_valid); + }); + } + } + } +} \ No newline at end of file diff --git a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml.cs b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml.cs index f5201220f..697243f50 100644 --- a/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml.cs +++ b/src/client/spark/view/Controls/Order/OrderDetailsPopupControl.xaml.cs @@ -36,16 +36,16 @@ namespace mbts.ui.spark.algo #endregion #region ItemsSource - public static readonly DependencyProperty ItemsSourceProperty = DependencyProperty.Register(nameof(ItemsSource), typeof(IEnumerable), typeof(OrderDetailsPopupControl), + public static readonly DependencyProperty ItemsSourceProperty = DependencyProperty.Register(nameof(ItemsSource), typeof(IEnumerable), typeof(OrderDetailsPopupControl), new PropertyMetadata(null, OnItemsSourceChanged, CoerceItemsSource)); - private static object CoerceItemsSource(DependencyObject d, object baseValue) { return baseValue as IEnumerable ?? Enumerable.Empty(); } + private static object CoerceItemsSource(DependencyObject d, object baseValue) { return baseValue as IEnumerable ?? Enumerable.Empty(); } private static void OnItemsSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) { var cvs = CollectionViewSource.GetDefaultView(e.NewValue); - cvs.GroupDescriptions.Add(new PropertyGroupDescription(nameof(IOrderTypeDefVM.is_bts_type))); - cvs.SortDescriptions.Add(new SortDescription(nameof(IOrderTypeDefVM.is_bts_type), ListSortDirection.Ascending)); + cvs.GroupDescriptions.Add(new PropertyGroupDescription(nameof(IOrderTypeVM.is_bts_type))); + cvs.SortDescriptions.Add(new SortDescription(nameof(IOrderTypeVM.is_bts_type), ListSortDirection.Ascending)); d.SetValue(ItemsViewPropertyKey, cvs); } - public IEnumerable ItemsSource { get => GetValue(ItemsSourceProperty) as IEnumerable; set => SetValue(ItemsSourceProperty, value); } + public IEnumerable ItemsSource { get => GetValue(ItemsSourceProperty) as IEnumerable; set => SetValue(ItemsSourceProperty, value); } #endregion #region ItemsView (ReadOnly) @@ -62,10 +62,10 @@ namespace mbts.ui.spark.algo #endregion #region SelectedItem - public static readonly DependencyProperty SelectedItemProperty = DependencyProperty.Register(nameof(SelectedItem), typeof(IOrderTypeDefVM), typeof(OrderDetailsPopupControl), + public static readonly DependencyProperty SelectedItemProperty = DependencyProperty.Register(nameof(SelectedItem), typeof(IOrderTypeVM), typeof(OrderDetailsPopupControl), new FrameworkPropertyMetadata(null, FrameworkPropertyMetadataOptions.BindsTwoWayByDefault)); - public IOrderTypeDefVM SelectedItem { get => GetValue(SelectedItemProperty) as IOrderTypeDefVM; set => SetValue(SelectedItemProperty, value); } + public IOrderTypeVM SelectedItem { get => GetValue(SelectedItemProperty) as IOrderTypeVM; set => SetValue(SelectedItemProperty, value); } #endregion void TrySetGridColumnWidths() {