diff --git a/src/client/spark/AlgoProvider/AlgoProviderFactory.cs b/src/client/spark/AlgoProvider/AlgoProviderFactory.cs index 52e8f66fa..b90ee87d6 100644 --- a/src/client/spark/AlgoProvider/AlgoProviderFactory.cs +++ b/src/client/spark/AlgoProvider/AlgoProviderFactory.cs @@ -2,6 +2,7 @@ using bts.api; using bts.api.core; +using mbts.spark.utilities; using mbts.ui.utility; using mbts.utils; @@ -18,7 +19,7 @@ using AlgoType = bts.api.orderman.CustomOrderDefinition.CustomOneofCase; namespace mbts.spark { class AlgoProviderFactory { [ImportingConstructor] - public AlgoProviderFactory(IAlgoStudioModel studio_model, DynamicOrderHelper dynamic_helper, ISecurityAuxiliaryDataModel security_auxiliary_model) { + public AlgoProviderFactory(IAlgoStudioModel studio_model, OrderFactory order_factory, ISecurityAuxiliaryDataModel security_auxiliary_model) { var from_conf = config.Configuration.get(); if (from_conf.rules.Count == 0) { // There seems to be a config race bug, where the returned config values are empty, despite having entries in spark.conf. @@ -38,7 +39,7 @@ namespace mbts.spark { AlgoType.Tick, AlgoType.Trigger, AlgoType.QueueHolder)), - ImmutableHashSet.CreateRange(dynamic_helper.dynamic_types)); + ImmutableHashSet.CreateRange(order_factory.dynamic_types())); var rules = new[] { // Glbx: Futures/Spreads new SecurityAlgoTypeSetImmutable( @@ -100,17 +101,27 @@ namespace mbts.spark { "\n\n\tAttachable\n" + attachable_rules.fmt_diagnostic("\n\t\t")); - security_algo_provider = new AlgoProvider(rules, studio_model, dynamic_helper, security_auxiliary_model); - attachable_algo_provider = new AttachableAlgoProvider(attachable_rules, studio_model, dynamic_helper, security_auxiliary_model); + security_algo_provider = new AlgoProvider( + rules, studio_model, order_factory, security_auxiliary_model); + attachable_algo_provider = new AttachableAlgoProvider( + attachable_rules, studio_model, order_factory, security_auxiliary_model); } else { var algo_type_data = EnumHelper.get_values_except(AlgoType.Dynamic, AlgoType.Composite, AlgoType.None) .Select(t => _get_type_data(t)) - .Concat(dynamic_helper.dynamic_types.Select(dt => _get_type_data(AlgoType.Dynamic, dt))) + .Concat(order_factory.dynamic_types().Select(dt => _get_type_data(AlgoType.Dynamic, dt))) .ToListLazy(); - var conf_sets = from_conf.rules.Select(r => _to_security_algo_set(r, dynamic_helper, algo_type_data)).ToList(); - security_algo_provider = new AlgoProvider(conf_sets.Select(tup => tup.standard).ToList(), studio_model, dynamic_helper, security_auxiliary_model); - attachable_algo_provider = new AttachableAlgoProvider(conf_sets.Select(tup => tup.attachable).ToList(), studio_model, dynamic_helper, security_auxiliary_model); + var conf_sets = from_conf.rules.Select(r => _to_security_algo_set(r, order_factory, algo_type_data)).ToList(); + security_algo_provider = new AlgoProvider( + conf_sets.Select(tup => tup.standard).ToList(), + studio_model, + order_factory, + security_auxiliary_model); + attachable_algo_provider = new AttachableAlgoProvider( + conf_sets.Select(tup => tup.attachable).ToList(), + studio_model, + order_factory, + security_auxiliary_model); } } @@ -134,7 +145,7 @@ namespace mbts.spark { static (SecurityAlgoTypeSetImmutable standard, SecurityAlgoTypeSetImmutable attachable) _to_security_algo_set( bts.config.AlgoTypeRule rule, - DynamicOrderHelper dynamic_helper, + OrderFactory order_factory, IEnumerable<(string name, AlgoType factory, string dynamic)> algo_type_data) { // var factory_types = ImmutableHashSet.Empty.ToBuilder(); @@ -144,23 +155,26 @@ namespace mbts.spark { foreach (var a in rule.algos) { if (Enum.TryParse(a.name, out AlgoType sys_algo) && sys_algo != AlgoType.Composite && sys_algo != AlgoType.Dynamic) { on_sys_match(sys_algo, a.is_attachable); - } else if (dynamic_helper.try_parse(a.name, out var dyn_type)) { - on_dyn_match(dyn_type, a.is_attachable); - } else { - foreach (var (name, factory, dynamic) in algo_type_data) { - if (Regex.Match(name, a.name).Success) { - switch (factory) { - case AlgoType.None: - case AlgoType.Composite: - // unexpected, but no need to crash - continue; - case AlgoType.Dynamic: - on_dyn_match(dynamic, a.is_attachable); - break; - default: - on_sys_match(factory, a.is_attachable); - break; - } + continue; + } + var dyn_desc = order_factory.dynamic_descriptor(a.name); + if (dyn_desc is not null) { + on_dyn_match(dyn_desc.DynamicOrderType, a.is_attachable); + continue; + } + foreach (var (name, factory, dynamic) in algo_type_data) { + if (Regex.Match(name, a.name).Success) { + switch (factory) { + case AlgoType.None: + case AlgoType.Composite: + // unexpected, but no need to crash + continue; + case AlgoType.Dynamic: + on_dyn_match(dynamic, a.is_attachable); + break; + default: + on_sys_match(factory, a.is_attachable); + break; } } } diff --git a/src/client/spark/AlgoProvider/AlgoTypeSet.cs b/src/client/spark/AlgoProvider/AlgoTypeSet.cs index 78cfdece2..713744970 100644 --- a/src/client/spark/AlgoProvider/AlgoTypeSet.cs +++ b/src/client/spark/AlgoProvider/AlgoTypeSet.cs @@ -80,7 +80,7 @@ namespace mbts.spark { public static IEnumerable define_algos( this AlgoTypeSetImmutable algo_set, - DynamicOrderHelper dynamic_helper, + Func dynamic_order_factory, Func fit_to_type = null, double display_qty_divisor = 1) => // @@ -101,13 +101,13 @@ namespace mbts.spark { } return def; }) - .Concat(algo_set.dynamic_types.Select(dynamic_helper.create_custom_defi)) + .Concat(algo_set.dynamic_types.Select(dynamic_order_factory)) .Select(AlgoData.from_custom_def); public static ImmutableDictionary match_algos( this IEnumerable security_algo_sets, SecurityCriteriaClause clause, - DynamicOrderHelper dynamic_helper, + Func dynamic_order_factory, Func fit_to_type = null, double display_qty_divisor = 1) { // @@ -117,7 +117,8 @@ namespace mbts.spark { continue; } else if (rv == null) { rv = ImmutableDictionary.CreateRange( - set.algo_type_set.define_algos(dynamic_helper, fit_to_type, display_qty_divisor) + set.algo_type_set.define_algos( + dynamic_order_factory, fit_to_type, display_qty_divisor) .Select(a => new KeyValuePair(a.key, a))); } else { foreach (var kv in rv) { diff --git a/src/client/spark/AlgoProvider/IAlgoProvider.cs b/src/client/spark/AlgoProvider/IAlgoProvider.cs index d613bbee8..44595b96a 100644 --- a/src/client/spark/AlgoProvider/IAlgoProvider.cs +++ b/src/client/spark/AlgoProvider/IAlgoProvider.cs @@ -9,6 +9,7 @@ using mbts.ui.utility; using mbts.utils; using Spark.Api.Orders; +using Spark.Core; using System; using System.Collections.Generic; @@ -34,17 +35,21 @@ namespace mbts.spark { readonly IAlgoStudioModel _studio_model; readonly ISecurityAuxiliaryDataModel _security_auxiliary_model; readonly IObservable> _studio_algos_source; - readonly DynamicOrderHelper _dynamic_helper; + readonly OrderFactory _order_factory; readonly AlgoTypeSetImmutable _full_set; - public AlgoProvider(IEnumerable algo_sets, IAlgoStudioModel studio_model, DynamicOrderHelper dynamic_helper, ISecurityAuxiliaryDataModel security_auxiliary_model) { + public AlgoProvider( + IEnumerable algo_sets, + IAlgoStudioModel studio_model, + OrderFactory order_factory, + ISecurityAuxiliaryDataModel security_auxiliary_model) { _security_algo_types = algo_sets; _studio_model = studio_model; - _dynamic_helper = dynamic_helper; + _order_factory = order_factory; _full_set = new AlgoTypeSetImmutable( ImmutableHashSet.CreateRange( EnumHelper.get_values_except(CustomOrderDefinition.CustomOneofCase.None, CustomOrderDefinition.CustomOneofCase.Dynamic, CustomOrderDefinition.CustomOneofCase.Composite)), - ImmutableHashSet.CreateRange(dynamic_helper.dynamic_types)); + ImmutableHashSet.CreateRange(_order_factory.dynamic_types())); _security_auxiliary_model = security_auxiliary_model; /// initialize with an empty table, so the /// @@ -72,12 +77,12 @@ namespace mbts.spark { .AppendTable(_security_algo_types .Select(s => s.algo_type_set) .Aggregate(AlgoTypeSetImmutable.empty, (a, b) => a.union_with(b)) - .define_algos(_dynamic_helper)); + .define_algos(t => _order_factory.custom_defi(t).assert_value())); public IObservable> subscribe_algos(SecurityCriteriaClause security_clause) { var system_algos = _security_algo_types.match_algos( security_clause, - _dynamic_helper, + t => _order_factory.custom_defi(t).assert_value(), def => _fit_to_type(def, security_clause, _security_algo_types)); return _studio_algos_source @@ -96,7 +101,7 @@ namespace mbts.spark { // i.e., non-studio algos var system_algos = _security_algo_types.match_algos( clause, - _dynamic_helper, + t => _order_factory.custom_defi(t).assert_value(), def => _fit_to_type(def, security, _security_algo_types), _security_auxiliary_model.get_display_quantity_divisor(security)); @@ -182,8 +187,12 @@ namespace mbts.spark { } class AttachableAlgoProvider : AlgoProvider, IAttachableAlgoProvider { - public AttachableAlgoProvider(IEnumerable algo_sets, IAlgoStudioModel studio_model, DynamicOrderHelper dynamic_helper, ISecurityAuxiliaryDataModel security_auxiliary_model) - : base(algo_sets, studio_model, dynamic_helper, security_auxiliary_model) { } + public AttachableAlgoProvider( + IEnumerable algo_sets, + IAlgoStudioModel studio_model, + OrderFactory order_factory, + ISecurityAuxiliaryDataModel security_auxiliary_model) + : base(algo_sets, studio_model, order_factory, security_auxiliary_model) { } // arbitrarily assign LimitOrderDefinition (this is just a placeholder; the real child is the attach target algo). // Note: although 'None' might seem approrpriate, the server requires a valid definition (perhaps this will change in the future). diff --git a/src/client/spark/Daemons/OrderTicketDaemon.cs b/src/client/spark/Daemons/OrderTicketDaemon.cs index 418460586..6c9278cc5 100644 --- a/src/client/spark/Daemons/OrderTicketDaemon.cs +++ b/src/client/spark/Daemons/OrderTicketDaemon.cs @@ -1,4 +1,4 @@ -using bts.api; +using bts.api; using bts.api.core; using bts.api.orderman; using bts.spark; @@ -31,6 +31,7 @@ namespace bts.shell { readonly UserSettingsHub _settings_hub; readonly ErrorReporter _error_reporter; readonly bool _close_on_send; + IReadOnlyDictionary _accounts = new Dictionary(0); IReadOnlyDictionary _md_map; TableUpdate<(SecurityImmutable? sec, OrderRecordImmutable order), uint> _orders; IDisposable _dispose; @@ -51,7 +52,8 @@ namespace bts.shell { bus.subscribe(SparkTags.ShowOrderTicketFromSecurityTag).OnDispatcher().Subscribe(_show_order_ticket), bus.subscribe(SparkTags.ShowOrderTicketTag).OnDispatcher().Subscribe(_show_order_ticket), bus.subscribe(SparkTags.ShowOrderTicketAutoLookupTag).Subscribe(_show_order_tickets), - bus.subscribe(SparkTags.ShowModifyOrderTag).OnDispatcher().Subscribe(_show_modify_order) + bus.subscribe(SparkTags.ShowModifyOrderTag).OnDispatcher().Subscribe(_show_modify_order), + bus.subscribe(SparkTags.AccountsTag).Subscribe(accs => _accounts = accs) ); } @@ -80,28 +82,17 @@ namespace bts.shell { }); } - void _show_order_ticket(OrderTicketParams ops) { - var def = ops.definition; - if (!_md_map.TryGetValue(def.SecurityKey, out SecurityMD smd)) { + void _show_order_ticket(OrderTicketParams ot_params) { + if (!_md_map.TryGetValue(ot_params.definition.SecurityKey, out SecurityMD smd)) { return; } - - if (def.Account.is_null_or_empty() && def.AccountId == 0) { - var settings = _settings_hub.current.get_ladder_profile(smd.security); - var default_account = settings?.value?.default_account; - if (default_account.HasValue) { - var mdef = def.CloneToMutable(); - // The order ticket will resolve AccountId to a name - mdef.AccountId = default_account.Value; - def = new(mdef); - } - } - + var def = _model.factory.order(smd.security, _accounts.Values.FirstOrNull()); + def.MergeFrom(ot_params.definition.CloneToMutable()); var accounts = _bus.subscribe(SparkTags.AccountsTag); var calc_buttons = Observable.Return(LadderSettings.Default.calculator_buttons); _show_order_window(new OrderTicket { DataContext = new NewOrderTicketVM( - _model, smd, accounts, def, ops.price, ops.quantity, calc_buttons) { + _model, smd, accounts, new(def), ot_params.price, ot_params.quantity, calc_buttons) { close_on_send = _close_on_send } }); diff --git a/src/client/spark/Modules/Trading/Ladder/VM/LadderSettingsVM.cs b/src/client/spark/Modules/Trading/Ladder/VM/LadderSettingsVM.cs index 1f02508a1..b0c966ec0 100644 --- a/src/client/spark/Modules/Trading/Ladder/VM/LadderSettingsVM.cs +++ b/src/client/spark/Modules/Trading/Ladder/VM/LadderSettingsVM.cs @@ -153,9 +153,7 @@ namespace mbts.spark { .Select(AlgoData.from_custom_def) .Select(algo_factory)); _algo_definitions.AddRange(_model.get_permitted_algos(security).dynamic_types - .Select(dyn_type => new CustomOrderDefinitionImmutable(new CustomOrderDefinition { - Dynamic = _model.dynamic_helper.create_def(dyn_type) - })) + .Select(dyn_type => _model.factory.custom_defi(dyn_type).assert_value()) .Select(AlgoData.from_custom_def) .Select(algo_factory)); _dispose = Disposable.Create( diff --git a/src/client/spark/Modules/Trading/OrderBook/OrderBookVM.cs b/src/client/spark/Modules/Trading/OrderBook/OrderBookVM.cs index 1ef53fcf7..5d9f987f1 100644 --- a/src/client/spark/Modules/Trading/OrderBook/OrderBookVM.cs +++ b/src/client/spark/Modules/Trading/OrderBook/OrderBookVM.cs @@ -121,7 +121,9 @@ namespace mbts.spark { _bus = bus; _model = model; _global_filter = global_filter; - _selected_params_mon = new OrderParamsAggregator(model.dynamic_helper, _selection_change_throttle, k => _cached_orders.TryGetValue(k, out var o) ? o.order : (OrderSecurityAlgo?)null); + _selected_params_mon = new OrderParamsAggregator( + _selection_change_throttle, + k => _cached_orders.TryGetValue(k, out var o) ? o.order : null); ladder_vm = new LadderVMContainer(bus, model, position_model, sec_meta_store); order_mod_vm = new OrderParamsVM( @@ -930,7 +932,8 @@ namespace mbts.spark { } } foreach (var p in dcs.empty_if_null().OrderBy(kv => kv.Key)) - _vm.current_algo_custom_state.Add(new NamedValueVM(p.Key, DynamicOrderHelper.fmt_param(p.Value))); + _vm.current_algo_custom_state.Add( + new NamedValueVM(p.Key, OrderFactory.fmt_dynamic_param(p.Value))); } } diff --git a/src/client/spark/Orders/OrderDataHelper.cs b/src/client/spark/Orders/OrderDataHelper.cs index bf7b5dc40..af546b7d2 100644 --- a/src/client/spark/Orders/OrderDataHelper.cs +++ b/src/client/spark/Orders/OrderDataHelper.cs @@ -48,142 +48,6 @@ namespace mbts.spark.utilities { } } - // at some point, user-default settings for orders can be managed here - // OrdersModel imports and exposes OrderFactory as a public property - [Export(typeof(OrderFactory))] - class OrderFactory : IDisposable { - static readonly OrderMetadata _default_order_metadata = new OrderMetadata { KeyBinding = "", Color = BTSColors.Orders.default_order }; - readonly AdminModel _admin_model; - readonly DynamicOrderHelper _dynamic_helper; - readonly IAlgoProvider _security_algo_provider; - readonly IReadOnlyDictionary, string> _algo_abbreviation_index; - readonly IReadOnlyDictionary _dynamic_descriptors; - IDisposable _dispose; - - [ImportingConstructor] - public OrderFactory(OrderService service, AdminModel admin_model, DynamicOrderHelper dynamic_helper, IAlgoProvider security_algo_provider) { - _admin_model = admin_model; - _dynamic_helper = dynamic_helper; - _dynamic_descriptors = service.get_registered_dynamic_order_types(new VoidMessage()) - .DynamicOrderDesc - .ToDictionary(d => d.DynamicOrderType); - _security_algo_provider = security_algo_provider; - var algo_name_index = new HashSet>(OneOf.ValueEqualityComparer); - // add standard types - algo_name_index.AddRange( - EnumHelper.get_values_except(CustomOrderDefinition.CustomOneofCase.None) - .Select(t => new OneOf(t))); - // add dynamic types - algo_name_index.AddRange(dynamic_helper.dynamic_types - .Select(dt => new OneOf(dt))); - // build abbreviation index - _algo_abbreviation_index = DisplayNameHelper.get_word_tree_abbreviations(algo_name_index, oneof => oneof.value.ToString(), OneOf.ValueEqualityComparer); - } - - public IObservable> subscribe_accounts() => _admin_model.on_accounts; - public IObservable> subscribe_users() => _admin_model.on_users; - public IObservable> subscribe_account_tuples() => _admin_model.on_account_tuples; - - #region Defaults - public CustomOrderDefinition.CustomOneofCase default_order_type(SecurityImmutable security) { - switch (security.ContractCase) { - case Security.ContractOneofCase.Synthetic: return CustomOrderDefinition.CustomOneofCase.Spreader; - default: return CustomOrderDefinition.CustomOneofCase.Limit; - } - } - - public TimeInForce default_time_in_force() => - TimeInForce.Day; - - public TimeInForce default_time_in_force(SecurityImmutable security) => - default_time_in_force(); - - public IEnumerable default_order_types() => - OrderDataHelper.exchange_order_types; - - public IEnumerable default_time_in_forces(SecurityImmutable security, CustomOrderDefinition.CustomOneofCase order_type, bool is_child = false) { - var tifs = EnumHelper.get_values_except(TimeInForce.Undefined); - if (order_type != CustomOrderDefinition.CustomOneofCase.Limit) { - tifs = tifs.Except(new[] { TimeInForce.Ioc }); - } - return tifs; - } - #endregion - - public OrderDefinitionImmutable order(SecurityImmutable security) => - new OrderDefinitionImmutable(order(security, _admin_model.get_default_account())); - - public OrderDefinition order(SecurityImmutable security, AccountTuple? account) { - var rv = new OrderDefinition { - SecurityKey = security.Id, - Side = Side.Buy, - TimeInForce = TimeInForce.Day, - CustomDef = OrderDataHelper.Defaults.CustomOrderDefinition(), - 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 = ManualOrderIndicator.Yes, - User = _admin_model.user.name, - UserId = _admin_model.user.id - }; - if (account.HasValue) { - rv.Account = account.Value.name; - rv.AccountId = account.Value.id; - } - return rv; - } - - public string abbreviate_algo(OneOf id) { - if (id == null) - throw new ArgumentNullException(nameof(id)); - if (id.value is string) - return _algo_abbreviation_index.TryGetValue(id, out string abb) ? abb : id.value.ToString(); - else if (id.value is CustomOrderDefinition.CustomOneofCase t) - return OrderDataHelper.abbreviate_algo_type(t); - return id.ToString(); - } - - // mutable definitions - public SpreaderOrderDefinition spreader_order(SecurityImmutable security, ExecutionStrategyImmutable strategy) => - new SpreaderOrderDefinition { - Security = security.CloneToMutable(), - ExecutionStrategy = strategy.CloneToMutable() - }; - - // immutable definitions - public SpreaderOrderDefinitionImmutable spreader_orderi(SecurityImmutable security, ExecutionStrategyImmutable strategy) => new SpreaderOrderDefinitionImmutable(spreader_order(security, strategy)); - - public OrderMetadata get_metadata(OrderRecordImmutable order) => get_metadata(order.Def.CustomDef.CustomCase); - - public OrderMetadata get_metadata(CustomOrderDefinition.CustomOneofCase order_type) => - order_type switch { - CustomOrderDefinition.CustomOneofCase.Market => new() { KeyBinding = "M", Color = BTSColors.Orders.market_order, NoProps = true }, - CustomOrderDefinition.CustomOneofCase.Limit => new() { KeyBinding = "L", Color = BTSColors.Orders.limit_order, NoProps = true }, - CustomOrderDefinition.CustomOneofCase.Stop => new() { KeyBinding = "S", Color = BTSColors.Orders.stop_order, NoProps = true }, - CustomOrderDefinition.CustomOneofCase.StopLimit => new() { KeyBinding = "SL", Color = BTSColors.Orders.stop_limit_order }, - CustomOrderDefinition.CustomOneofCase.GlbxIceberg => new() { KeyBinding = "GB", Color = BTSColors.Orders.glbx_iceberg_order }, - CustomOrderDefinition.CustomOneofCase.Iceberg => new() { KeyBinding = "I", Color = BTSColors.Orders.iceberg_order }, - CustomOrderDefinition.CustomOneofCase.TimeBox => new() { KeyBinding = "TB", Color = BTSColors.Orders.time_box_order }, - CustomOrderDefinition.CustomOneofCase.Tick => new() { KeyBinding = "T", Color = BTSColors.Orders.tick_order }, - CustomOrderDefinition.CustomOneofCase.Lean => new() { KeyBinding = "L", Color = BTSColors.Orders.lean_order }, - CustomOrderDefinition.CustomOneofCase.Join => new() { KeyBinding = "J", Color = BTSColors.Orders.join_order }, - CustomOrderDefinition.CustomOneofCase.Top => new() { KeyBinding = "D", Color = BTSColors.Orders.top_order }, - CustomOrderDefinition.CustomOneofCase.Cover => new() { KeyBinding = "C", Color = BTSColors.Orders.cover_order }, - CustomOrderDefinition.CustomOneofCase.Oco => new() { KeyBinding = "C", Color = BTSColors.Orders.oco_order }, - CustomOrderDefinition.CustomOneofCase.Pricer => new() { KeyBinding = "C", Color = BTSColors.Orders.pricer_order }, - CustomOrderDefinition.CustomOneofCase.Offset => new() { KeyBinding = "O", Color = BTSColors.Orders.off_order }, - CustomOrderDefinition.CustomOneofCase.Trigger => new() { KeyBinding = "T", Color = BTSColors.Orders.trigger_order }, - CustomOrderDefinition.CustomOneofCase.Spreader => new() { KeyBinding = "", Color = BTSColors.Orders.spreader_order }, - CustomOrderDefinition.CustomOneofCase.Dynamic => new() { KeyBinding = "", Color = BTSColors.Orders.top_order }, - _ => _default_order_metadata - }; - - public void Dispose() => - Disposable.dispose(ref _dispose); - } - static class OrderDataHelper { class AlgoTypeCaseDescriptorData { public readonly IReadOnlyList child_algo_data; diff --git a/src/client/spark/Orders/OrderFactory.cs b/src/client/spark/Orders/OrderFactory.cs new file mode 100644 index 000000000..bf6380d27 --- /dev/null +++ b/src/client/spark/Orders/OrderFactory.cs @@ -0,0 +1,323 @@ +#nullable enable +namespace mbts.spark.utilities { + using bts; + using bts.api; + using bts.api.core; + using bts.api.orderman; + using bts.collections; + using bts.spark; + + using mbts.ui; + using mbts.ui.utilities; + using mbts.ui.utility; + using mbts.utils; + + using Spark.Core; + using Spark.Core.Disposables; + + using System; + using System.Collections.Generic; + using System.Composition; + using System.Linq; + using System.Reactive.Linq; + + using OrderType = bts.api.orderman.CustomOrderDefinition.CustomOneofCase; + using DynamicOrderParamType = bts.api.orderman.DynamicOrderParam.ValueOneofCase; + + [Export(typeof(OrderFactory))] + class OrderFactory : IDisposable { + static readonly OrderMetadata _default_order_metadata = new() { + KeyBinding = "", + Color = BTSColors.Orders.default_order + }; + readonly AdminModel _admin_model; + readonly IReadOnlyDictionary, string> _algo_abbreviation_index; + readonly IReadOnlyDictionary _dynamic_descriptors; + + IDisposable? _dispose; + + [ImportingConstructor] + public OrderFactory(OrderService service, AdminModel admin_model) { + _admin_model = admin_model; + _dynamic_descriptors = service.get_registered_dynamic_order_types(new VoidMessage()) + .DynamicOrderDesc + .ToDictionary(d => d.DynamicOrderType); + var algo_name_index = new HashSet>( + OneOf.ValueEqualityComparer); + // add standard types + algo_name_index.AddRange( + EnumHelper.get_values_except(OrderType.None) + .Select(t => new OneOf(t))); + // add dynamic types + algo_name_index.AddRange(_dynamic_descriptors.Keys + .Select(dt => new OneOf(dt))); + // build abbreviation index + _algo_abbreviation_index = DisplayNameHelper.get_word_tree_abbreviations( + algo_name_index, + oneof => oneof.value.ToString(), + OneOf.ValueEqualityComparer); + } + + public static string? fmt_dynamic_param(DynamicOrderParam? dp) { + if (dp is null) { + return null; + } + return dp.ValueCase switch { + DynamicOrderParamType.AsArray => ", ".join(dp.AsArray.Element.Select(fmt_dynamic_param)), + DynamicOrderParamType.AsBool => dp.AsBool.ToString(), + DynamicOrderParamType.AsDouble => dp.AsDouble.ToString(), + DynamicOrderParamType.AsEnumerated => dp.AsEnumerated.EnumValue, + DynamicOrderParamType.AsInt32 => dp.AsInt32.ToString(), + DynamicOrderParamType.AsQuantity => dp.AsQuantity.ToString(), + DynamicOrderParamType.AsString => dp.AsString, + _ => $"({dp.ValueCase})", + }; + } + + public static DynamicOrderParam init_dynamic_param(DynamicOrderParamDescriptor descriptor) { + var rv = new DynamicOrderParam(); + switch (descriptor.ParamType.DescriptorCase) { + case DynamicOrderTypeDescriptor.DescriptorOneofCase.Array: + rv.AsArray = new DynamicOrderArray(); + break; + case DynamicOrderTypeDescriptor.DescriptorOneofCase.Enumerated: + rv.AsEnumerated = new() { + EnumValue = descriptor.ParamType.Enumerated.Element.FirstOrDefault() + }; + break; + case DynamicOrderTypeDescriptor.DescriptorOneofCase.Primitive: + switch (descriptor.ParamType.Primitive) { + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveBool: rv.AsBool = false; break; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveDouble: rv.AsDouble = 0.0; break; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveInt: rv.AsInt32 = 0; break; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveOrderDef: rv.AsOrderDef = new(); break; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveString: rv.AsString = string.Empty; break; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveSecurityKey: + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveUint: rv.AsUint32 = 0u; break; + case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveQuantity: rv.AsQuantity = new(); break; + } + break; + case DynamicOrderTypeDescriptor.DescriptorOneofCase.Structure: + rv.AsStruct = new(); + break; + } + return rv; + } + + public static SpreaderOrderDefinition spreader_def() => new() { + ExecutionStrategy = new ExecutionStrategy() + }; + + public DynamicOrderDescriptor? dynamic_descriptor(string type) => + _dynamic_descriptors.GetValueOrDefault(type); + + public DynamicOrderDefinition? dynamic_def(string type) { + if (!_dynamic_descriptors.TryGetValue(type, out var desc)) { + return null; + } + var def = new DynamicOrderDefinition { DynamicOrderType = type }; + foreach (var p in desc.ParamDesc) { + def.OrderParams[p.ParamName] = init_dynamic_param(p); + } + return def; + } + + public OrderType default_order_type(SecurityImmutable security) => + security.ContractCase switch { + Security.ContractOneofCase.Synthetic => OrderType.Spreader, + _ => OrderType.Limit, + }; + + public TimeInForce default_time_in_force() => + TimeInForce.Day; + + public TimeInForce default_time_in_force(SecurityImmutable security) => + default_time_in_force(); + + public IEnumerable default_order_types() => + OrderDataHelper.exchange_order_types; + + public IEnumerable default_time_in_forces( + SecurityImmutable security, + OrderType order_type, + bool is_child = false + ) { + var tifs = EnumHelper.get_values_except(TimeInForce.Undefined); + if (order_type != OrderType.Limit) { + tifs = tifs.Except(new[] { TimeInForce.Ioc }); + } + return tifs; + } + + public IEnumerable dynamic_types() => + _dynamic_descriptors.Keys; + + public CustomOrderDefinitionImmutable? custom_defi(string type_name) { + if (Enum.TryParse(type_name, out OrderType sys_type)) { + return _custom_def(sys_type); + } + var dyn_def = dynamic_def(type_name); + if (dyn_def is null) { + return null; + } + return new(new() { Dynamic = dyn_def }); + } + + public OrderDefinition order(SecurityImmutable security, AccountTuple? account = null) { + var rv = new OrderDefinition { + SecurityKey = security.Id, + Side = Side.Buy, + TimeInForce = TimeInForce.Day, + CustomDef = OrderDataHelper.Defaults.CustomOrderDefinition(), + 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 = ManualOrderIndicator.Yes, + User = _admin_model.user.name, + UserId = _admin_model.user.id + }; + if (account.HasValue) { + rv.Account = account.Value.name; + rv.AccountId = account.Value.id; + } + return rv; + } + + public string abbreviate_algo(OneOf id) { + if (id is null) { + throw new ArgumentNullException(nameof(id)); + } + if (id.value is string) { + return _algo_abbreviation_index.GetValueOrDefault(id) ?? + id.value.ToString() ?? + string.Empty; + } + if (id.value is OrderType t) { + return OrderDataHelper.abbreviate_algo_type(t); + } + return id.ToString() ?? string.Empty; + } + + public OrderMetadata get_metadata(OrderRecordImmutable order) => + get_metadata(order.Def.CustomDef.CustomCase); + + public OrderMetadata get_metadata(OrderType order_type) => + order_type switch { + OrderType.Market => new() { KeyBinding = "M", Color = BTSColors.Orders.market_order, NoProps = true }, + OrderType.Limit => new() { KeyBinding = "L", Color = BTSColors.Orders.limit_order, NoProps = true }, + OrderType.Stop => new() { KeyBinding = "S", Color = BTSColors.Orders.stop_order, NoProps = true }, + OrderType.StopLimit => new() { KeyBinding = "SL", Color = BTSColors.Orders.stop_limit_order }, + OrderType.GlbxIceberg => new() { KeyBinding = "GB", Color = BTSColors.Orders.glbx_iceberg_order }, + OrderType.Iceberg => new() { KeyBinding = "I", Color = BTSColors.Orders.iceberg_order }, + OrderType.TimeBox => new() { KeyBinding = "TB", Color = BTSColors.Orders.time_box_order }, + OrderType.Tick => new() { KeyBinding = "T", Color = BTSColors.Orders.tick_order }, + OrderType.Lean => new() { KeyBinding = "L", Color = BTSColors.Orders.lean_order }, + OrderType.Join => new() { KeyBinding = "J", Color = BTSColors.Orders.join_order }, + OrderType.Top => new() { KeyBinding = "D", Color = BTSColors.Orders.top_order }, + OrderType.Cover => new() { KeyBinding = "C", Color = BTSColors.Orders.cover_order }, + OrderType.Oco => new() { KeyBinding = "C", Color = BTSColors.Orders.oco_order }, + OrderType.Pricer => new() { KeyBinding = "C", Color = BTSColors.Orders.pricer_order }, + OrderType.Offset => new() { KeyBinding = "O", Color = BTSColors.Orders.off_order }, + OrderType.Trigger => new() { KeyBinding = "T", Color = BTSColors.Orders.trigger_order }, + OrderType.Spreader => new() { KeyBinding = "", Color = BTSColors.Orders.spreader_order }, + OrderType.Dynamic => new() { KeyBinding = "", Color = BTSColors.Orders.top_order }, + _ => _default_order_metadata + }; + + public SpreaderOrderDefinition spreader_order( + SecurityImmutable security, ExecutionStrategyImmutable strategy) => + new() { + Security = security.CloneToMutable(), + ExecutionStrategy = strategy.CloneToMutable() + }; + + public SpreaderOrderDefinitionImmutable spreader_orderi( + SecurityImmutable security, ExecutionStrategyImmutable strategy) => + new(spreader_order(security, strategy)); + + public void Dispose() => + Disposable.dispose(ref _dispose); + + static CustomOrderDefinition _custom_def() => + new() { Limit = _limit_def() }; + + static CustomOrderDefinition _custom_def( + OrderType type) { + var rv = new CustomOrderDefinition(); + switch (type) { + case OrderType.Market: rv.Market = _market_def(); break; + case OrderType.Limit: rv.Limit = _limit_def(); break; + case OrderType.Stop: rv.Stop = _stop_def(); break; + case OrderType.StopLimit: rv.StopLimit = _stop_limit_def(); break; + case OrderType.Iceberg: rv.Iceberg = _iceberg_def(); break; + case OrderType.GlbxIceberg: rv.GlbxIceberg = _glbx_iceberg_def(); break; + case OrderType.TimeBox: rv.TimeBox = _time_box_def(); break; + case OrderType.Tick: rv.Tick = _tick_def(); break; + case OrderType.Lean: rv.Lean = _lean_def(); break; + case OrderType.Join: rv.Join = _join_def(); break; + case OrderType.Top: rv.Top = _top_def(); break; + case OrderType.Cover: rv.Cover = _cover_def(); break; + case OrderType.Oco: rv.Oco = _oco_def(); break; + case OrderType.Pricer: rv.Pricer = _pricer_def(); break; + case OrderType.Offset: rv.Offset = _offset_def(); break; + case OrderType.Trigger: rv.Trigger = _trigger_def(); break; + case OrderType.Spreader: rv.Spreader = spreader_def(); break; + case OrderType.Dynamic: rv.Dynamic = _dynamic_def(); break; + default: + OrderTypeVMFactory.GenericOrderFactory.setup_generic_custom_order(rv, type); + break; + } + return rv; + } + + static MarketOrderDefinition _market_def() => new(); + static LimitOrderDefinition _limit_def() => new(); + static StopOrderDefinition _stop_def() => new(); + static StopLimitOrderDefinition _stop_limit_def() => new(); + static GLBXIcebergOrderDefinition _glbx_iceberg_def() => new() { MaxShowQuantity = 1 }; + static IcebergOrderDefinition _iceberg_def() => + new() { Child = _custom_def(), ShowQuantity = 1 }; + static TimeBoxOrderDefinition _time_box_def() => new() { + Child = _custom_def(), + Start = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(DateTime.UtcNow), + Stop = Google.Protobuf.WellKnownTypes.Timestamp.FromDateTime(DateTime.UtcNow) + }; + static TickOrderDefinition _tick_def() => new() { + Child = _custom_def(), + CrossThreshold = new() { Absolute = 1 } + }; + static LeanOrderDefinition _lean_def() => new() { + Child = _custom_def(), + CrossThreshold = new() { Absolute = 1 }, + MaxChaseTicks = 2 + }; + static JoinOrderDefinition _join_def() => new() { + Child = _custom_def(), + JoinThreshold = new() { Absolute = 1 } + }; + static TopOrderDefinition _top_def() => new() { + Child = _custom_def(), + TopThreshold = new() { Absolute = 1 } + }; + static CoverOrderDefinition _cover_def() => new() { + Child = _custom_def(), + Hedge = _custom_def(), + HedgeTicks = 1 + }; + static OCOOrderDefinition _oco_def() => new() { + Child = _custom_def(), + Other = _custom_def(), + OtherSide = RelativeSide.Same + }; + static PricerOrderDefinition _pricer_def() => new() { Child = _custom_def() }; + static OffsetOrderDefinition _offset_def() => new() { Child = _custom_def(), }; + static TriggerOrderDefinition _trigger_def() => new() { + Child = _custom_def(), + TriggerCondition = new TriggerCondition(), + TriggerAction = new TriggerAction(), + }; + static DynamicOrderDefinition _dynamic_def() => new(); + } +} diff --git a/src/client/spark/Orders/OrderParamsAggregator.cs b/src/client/spark/Orders/OrderParamsAggregator.cs index 6e7cc6207..153233966 100644 --- a/src/client/spark/Orders/OrderParamsAggregator.cs +++ b/src/client/spark/Orders/OrderParamsAggregator.cs @@ -33,11 +33,9 @@ namespace mbts.spark { readonly CommonValueMonitor _account_mon = new CommonValueMonitor(); readonly CommonValueMonitor _all_active_mon = new CommonValueMonitor(); readonly CommonValueMonitorMultiplexor _group_mon = new CommonValueMonitorMultiplexor(); - readonly DynamicOrderHelper _dyn_helper; readonly Func _lookup_order; - public OrderParamsAggregator(DynamicOrderHelper dyn_helper, TimeSpan throttle, Func lookup_order) { - _dyn_helper = dyn_helper; + public OrderParamsAggregator(TimeSpan throttle, Func lookup_order) { _throttle = throttle; _lookup_order = lookup_order; _group_mon.add_member_mon(_algo_def_mon, _build_algo_tree); diff --git a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderHelper.cs b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderHelper.cs deleted file mode 100644 index e6999cb9c..000000000 --- a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderHelper.cs +++ /dev/null @@ -1,135 +0,0 @@ -using bts.api; -using bts.api.orderman; -using bts.utils; - -using Google.Protobuf.Reflection; - -using System; -using System.Collections.Generic; -using System.Composition; -using System.Linq; -using System.Reactive.Linq; - -namespace mbts.spark { - [Export] - class DynamicOrderHelper { - static readonly IReadOnlyDictionary _descriptor_case_index = - ProtoHelper.get_oneof_descriptor_index(nameof(DynamicOrderParam.ValueCase)); - - readonly Dictionary _dyn_types = new Dictionary(StringComparer.CurrentCultureIgnoreCase); - - [ImportingConstructor] - public DynamicOrderHelper(OrderService order_service) { - foreach (var dt in order_service.get_registered_dynamic_order_types(new VoidMessage()).DynamicOrderDesc) - _dyn_types[dt.DynamicOrderType] = dt; - } - - public IEnumerable dynamic_types => _dyn_types.Keys; - - public static string fmt_param(DynamicOrderParam dyn_param) { - if (dyn_param == null) - return null; - switch (dyn_param.ValueCase) { - case DynamicOrderParam.ValueOneofCase.AsArray: - return string.Join(", ", dyn_param.AsArray.Element.Select(fmt_param)); - case DynamicOrderParam.ValueOneofCase.AsBool: - return dyn_param.AsBool.ToString(); - case DynamicOrderParam.ValueOneofCase.AsDouble: - return dyn_param.AsDouble.ToString(); - case DynamicOrderParam.ValueOneofCase.AsEnumerated: - return dyn_param.AsEnumerated.EnumValue; - case DynamicOrderParam.ValueOneofCase.AsInt32: - return dyn_param.AsInt32.ToString(); - case DynamicOrderParam.ValueOneofCase.AsQuantity: - return dyn_param.AsQuantity.ToString(); - case DynamicOrderParam.ValueOneofCase.AsString: - return dyn_param.AsString; - default: - // implement additional cases as needed - // (as of 4/17/20, this method is only used to format - // dynamic orders' CustomState params in the orderbook) - return $"({dyn_param.ValueCase})"; - } - } - - public void add_dynamic_order_defs(List defs, Func factory) { - foreach (var d in _dyn_types.Values) { - var dorder = factory(CustomOrderDefinition.CustomOneofCase.Dynamic); - dorder.Dynamic.DynamicOrderType = d.DynamicOrderType; - var ddef = dorder.Dynamic; - //Add only the descriptor here for reflection later - add_dynamic_params(ref ddef); - defs.Add(new CustomOrderDefinitionImmutable(dorder)); - } - } - - public bool try_parse(string str, out string dynamic_type) { - if (_dyn_types.TryGetValue(str, out var desc)) { - dynamic_type = desc.DynamicOrderType; - return true; - } - dynamic_type = null; - return false; - } - - internal DynamicOrderDescriptor get_descriptor(string dynamic_type) => - _dyn_types.TryGetValue(dynamic_type, out var desc) ? desc : new DynamicOrderDescriptor(); - - internal CustomOrderDefinitionImmutable create_custom_defi(string dynamic_type) => - new CustomOrderDefinitionImmutable(new CustomOrderDefinition { Dynamic = create_def(dynamic_type) }); - - internal DynamicOrderDefinition create_def(string dynamic_type) { - var desc = get_descriptor(dynamic_type); - var def = new DynamicOrderDefinition { DynamicOrderType = dynamic_type }; - add_dynamic_params(ref def); - return def; - } - - internal void add_dynamic_params(ref DynamicOrderDefinition dynamic_def) { - var desc = get_descriptor(dynamic_def.DynamicOrderType); - foreach (var p in desc.ParamDesc) - dynamic_def.OrderParams[p.ParamName] = init_param(p); - } - - internal static DynamicOrderParam init_param(DynamicOrderParamDescriptor descriptor) { - var param = new DynamicOrderParam(); - switch (descriptor.ParamType.DescriptorCase) { - case DynamicOrderTypeDescriptor.DescriptorOneofCase.Array: param.AsArray = new DynamicOrderArray(); break; - case DynamicOrderTypeDescriptor.DescriptorOneofCase.Enumerated: param.AsEnumerated = new DynamicOrderEnumerated { EnumValue = descriptor.ParamType.Enumerated.Element.FirstOrDefault() }; break; - case DynamicOrderTypeDescriptor.DescriptorOneofCase.Primitive: - switch (descriptor.ParamType.Primitive) { - case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveBool: param.AsBool = false; break; - case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveDouble: param.AsDouble = 0.0; break; - case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveInt: param.AsInt32 = 0; break; - case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveOrderDef: param.AsOrderDef = new CustomOrderDefinition(); break; - case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveString: param.AsString = string.Empty; break; - case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveSecurityKey: - case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveUint: param.AsUint32 = 0u; break; - case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveQuantity: param.AsQuantity = new bts.spark.QuantityMeasure(); break; - } - break; - case DynamicOrderTypeDescriptor.DescriptorOneofCase.Structure: param.AsStruct = new DynamicOrderStruct(); break; - } - return param; - } - - internal static string get_enumerated_value(DynamicOrderParam param) => param?.AsEnumerated?.EnumValue; - internal static void set_enumerated_value(DynamicOrderParam param, string value) { - if (param == null) { - return; - } else if (param.ValueCase != DynamicOrderParam.ValueOneofCase.AsEnumerated) { - param.AsEnumerated = new DynamicOrderEnumerated(); - } - param.AsEnumerated.EnumValue = value ?? string.Empty; - } - - internal static bts.spark.QuantityMeasureImmutable? get_quantity_value(DynamicOrderParam param) { - return new bts.spark.QuantityMeasureImmutable(param?.AsQuantity); - } - internal static void set_quantity_value(DynamicOrderParam param, bts.spark.QuantityMeasureImmutable? value) { - if (param == null) - return; - param.AsQuantity = value?.CloneToMutable(); - } - } -} diff --git a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderParamVM.cs b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderParamVM.cs index d483a2bd9..ad9ec798f 100644 --- a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderParamVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderParamVM.cs @@ -5,6 +5,7 @@ namespace mbts.spark { using Google.Protobuf.Reflection; + using mbts.spark.utilities; using mbts.ui.shell; using Spark.Core.Disposables; @@ -28,7 +29,7 @@ namespace mbts.spark { abstract class DynamicOrderParamVM : DisposableViewModelBase, IDynamicOrderParamVM { protected DynamicOrderParamVM(DynamicOrderParamDescriptor descriptor) - : this(descriptor, DynamicOrderHelper.init_param(descriptor)) { } + : this(descriptor, OrderFactory.init_dynamic_param(descriptor)) { } private DynamicOrderParamVM(DynamicOrderParamDescriptor descriptor, DynamicOrderParam param) { this.descriptor = descriptor; @@ -76,12 +77,15 @@ namespace mbts.spark { public ObservableCollection elements { get; } public string selected_element { - get => DynamicOrderHelper.get_enumerated_value(param); + get => param?.AsEnumerated?.EnumValue; set { - var orig = selected_element; - DynamicOrderHelper.set_enumerated_value(param, value); - if (selected_element != orig) - RaisePropertyChanged(); + using var _ = detect_property_change(); + if (param is null) { + return; + } else if (param.ValueCase != DynamicOrderParam.ValueOneofCase.AsEnumerated) { + param.AsEnumerated = new DynamicOrderEnumerated(); + } + param.AsEnumerated.EnumValue = value ?? string.Empty; } } string IDynamicOrderParamVM.value { get => selected_element; set => selected_element = value; } @@ -110,12 +114,13 @@ namespace mbts.spark { QuantityMeasureImmutable? IDynamicOrderParamVM.value { get => quantity; set => quantity = value; } public QuantityMeasureImmutable? quantity { - get => DynamicOrderHelper.get_quantity_value(param); + get => new(param?.AsQuantity); set { - var orig = quantity; - DynamicOrderHelper.set_quantity_value(param, value); - if (quantity != orig) - RaisePropertyChanged(); + using var _ = detect_property_change(); + if (param is null) { + return; + } + param.AsQuantity = value?.CloneToMutable(); } } diff --git a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs index 0516c7d12..2fe73d27f 100644 --- a/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs +++ b/src/client/spark/Orders/OrderTypeVMs/DynamicOrderVM.cs @@ -53,15 +53,21 @@ namespace mbts.spark { _sync_dynamic_params(); protected override IEnumerable get_selector_data() => - OrderDataHelper.get_child_algo_data(new CustomOrderDefinition { - Dynamic = model?.dynamic_helper?.create_def(dyn_type) ?? new DynamicOrderDefinition() - }); + OrderDataHelper.get_child_algo_data( + model?.factory?.custom_defi(dyn_type) ?? new(new() { Dynamic = new() })); void _sync_dynamic_params() { - if (model != null) { - var desc = model.dynamic_helper.get_descriptor(dyn_type); - _parameters.SyncWithDictionary(desc.ParamDesc.Where(_is_value_param_desc).ToDictionary(p => p.ParamName), _mk_param_vm); + if (model is null) { + return; } + var desc = model.factory.dynamic_descriptor(dyn_type); + if (desc is null) { + _parameters.Clear(); + return; + } + _parameters.SyncWithDictionary( + desc.ParamDesc.Where(_is_value_param_desc).ToDictionary(p => p.ParamName), + _mk_param_vm); } static bool _is_value_param_desc(DynamicOrderParamDescriptor desc) => @@ -82,13 +88,33 @@ namespace mbts.spark { case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveString: return mk(DynamicOrderParam.AsStringFieldNumber, v => v, v => v); case DynamicOrderPrimitiveDescriptor.DynamicOrderPrimitiveQuantity: { var qm = new DynamicOrderQuantityVM(descriptor); - return attached(qm, DynamicOrderHelper.get_quantity_value, DynamicOrderHelper.set_quantity_value, new QuantityMeasure { Ratio = 1.0, Absolute = 1 }); + return attached( + qm, + param => new(param?.AsQuantity), + (param, value) => { + if (param is null) { + return; + } + param.AsQuantity = value?.CloneToMutable(); + }, + new QuantityMeasure { Ratio = 1.0, Absolute = 1 }); } default: throw ExceptionBuilder.Argument.unexpected_case(descriptor.ParamType.Primitive, nameof(descriptor)); } case DynamicOrderTypeDescriptor.DescriptorOneofCase.Enumerated: var pvm = new DynamicOrderEnumeratedVM(descriptor); - attached(pvm, DynamicOrderHelper.get_enumerated_value, DynamicOrderHelper.set_enumerated_value); + attached( + pvm, + p => p?.AsEnumerated?.EnumValue, + (param, value) => { + if (param is null) { + return; + } + if (param.ValueCase != DynamicOrderParam.ValueOneofCase.AsEnumerated) { + param.AsEnumerated = new DynamicOrderEnumerated(); + } + param.AsEnumerated.EnumValue = value ?? string.Empty; + }); return pvm; default: throw ExceptionBuilder.Argument.unexpected_case(descriptor.ParamType.DescriptorCase, nameof(descriptor)); } diff --git a/src/client/spark/Orders/OrdersModel.cs b/src/client/spark/Orders/OrdersModel.cs index 1f78cb084..214c8b2be 100644 --- a/src/client/spark/Orders/OrdersModel.cs +++ b/src/client/spark/Orders/OrdersModel.cs @@ -51,7 +51,6 @@ readonly MBOService _mbo_service; readonly SpreaderModel _spreader; readonly ErrorReporter _error; - readonly DynamicOrderHelper _dynamic_helper; readonly OrderActivitySummarizer _activity; readonly TableUpdateDemuxer _security_orders_demuxer; readonly TableUpdateDemuxer _security_working_orders_with_piq_demuxer; @@ -70,7 +69,6 @@ PositionService position_service, MBOService mbo_service, SpreaderModel spreader, - DynamicOrderHelper dynamic_helper, AdminModel admin_model, IAlgoStudioModel algo_model, ISecurityAuxiliaryDataModel security_auxiliary_model, @@ -90,7 +88,6 @@ _error = error; _algo_provider = algo_provider; _attachable_algo_provider = attachable_algo_provider; - _dynamic_helper = dynamic_helper; this.admin_model = admin_model; this.algo_model = algo_model; this.md_auxiliary_model = md_auxiliary_model; @@ -253,7 +250,6 @@ #region Output public OrderFactory factory => _factory; public SpreaderModel spreader => _spreader; - public DynamicOrderHelper dynamic_helper => _dynamic_helper; public IObservable on_orders => _data_source.orders; public IObservable on_order_tuples_with_piq { get; } public IObservable> on_order_tuples { get; } diff --git a/src/client/spark/view/Shell/ShellModel.cs b/src/client/spark/view/Shell/ShellModel.cs index 2ae2e67bc..2035e5831 100644 --- a/src/client/spark/view/Shell/ShellModel.cs +++ b/src/client/spark/view/Shell/ShellModel.cs @@ -141,7 +141,6 @@ typeof(shell.WindowManager), typeof(OrderFactory), typeof(AlgoProviderFactory), - typeof(DynamicOrderHelper), typeof(SecurityResolver), typeof(AdminModel), typeof(AlgoStudioFlatDefinitionModel), diff --git a/src/client/spark_core/utils/StringExtensions.cs b/src/client/spark_core/utils/StringExtensions.cs index 62221ce63..555f00d4f 100644 --- a/src/client/spark_core/utils/StringExtensions.cs +++ b/src/client/spark_core/utils/StringExtensions.cs @@ -28,7 +28,7 @@ namespace Spark.Core { str is not null && value is not null && str.Contains(value); [Pure] - public static string join(this string? str, IEnumerable values) => + public static string join(this string? str, IEnumerable values) => string.Join(str, values); [Pure]