diff --git a/src/client/spark/Admin/AdminModel.cs b/src/client/spark/Admin/AdminModel.cs index 43c6b6ec9..d8a73ab1b 100644 --- a/src/client/spark/Admin/AdminModel.cs +++ b/src/client/spark/Admin/AdminModel.cs @@ -1,6 +1,7 @@ using bts; using bts.api.admin; using bts.api.core; +using bts.utils; using System; using System.Collections.Generic; using System.ComponentModel.Composition; @@ -16,7 +17,7 @@ namespace mbts.spark { IReadOnlyDictionary _account_map = DictionaryHelper.empty(); [ImportingConstructor] - AdminModel(AdminService service, [Import]UserTuple user) { + AdminModel(AdminService service, UserTuple user) { this.user = user; // accounts on_accounts = service.subscribei_admin_data() @@ -30,12 +31,24 @@ namespace mbts.spark { new Dictionary(0)); // users on_users = Observable.Return(DictionaryHelper.wrap_value(user.id, user.name)); + all_user_tuples = user.permissions == UserTuple.Permissions.Admin ? + service.subscribei_admin_data() + .Select(u => u.all.TryFirst()) + .Where(ad => ad.HasValue) + .Select(ad => ad.Value.Users + .Where(u => user.can_access_user_data(u.Id)) + .Select(u => new UserTuple(u.Id, u.Name)) + .ToDictionary(UserTuple.key_fn)) + .Table(UserTuple.key_fn) + .Cache() : + Observable.Return(TableUpdate.mk_empty(UserTuple.key_fn).with_added(new[] { user })); // internal subs _dispose = on_accounts.Subscribe(map => _account_map = map); } public IObservable> on_users { get; } public IObservable> on_accounts { get; } + public IObservable> all_user_tuples { get; } public IObservable> on_account_tuples => on_accounts.Select(d => d.Select(kv => new AccountTuple(kv.Key, kv.Value)).ToList()); public IObservable> permission_filter(IObservable> positions, Func get_account_id) where TKey : IEquatable => diff --git a/src/client/spark/Modules/Spreader/SpreaderModel.cs b/src/client/spark/Modules/Spreader/SpreaderModel.cs index f34af26ab..d18c0a9ce 100644 --- a/src/client/spark/Modules/Spreader/SpreaderModel.cs +++ b/src/client/spark/Modules/Spreader/SpreaderModel.cs @@ -1,5 +1,8 @@ -using bts.api; +using bts; +using bts.api; +using bts.api.core; using bts.api.synthetic; +using bts.collections; using bts.spark; using mbts.ui.shell; using System; @@ -18,11 +21,36 @@ namespace mbts.spark { readonly uint _user_id; [ImportingConstructor] - public SpreaderModel(IBus bus, SyntheticSecurityService service, ErrorReporter error, [Import(LoginContainer.Exports.UserID)]uint user_id) { + public SpreaderModel(IBus bus, SyntheticSecurityService service, AdminModel admin_model, ErrorReporter error, [Import(LoginContainer.Exports.UserID)]uint user_id) { _bus = bus; _service = service; _error = error; _user_id = user_id; + // synthetic tuples + var strategy_source = _bus.subscribe(SparkTags.SyntheticstrategiesTag) + .Select(map => MappedDictionary.create(map, (k, v) => (k, v))) + .Table(tup => tup.security_id); + + var synthetic_source = _bus.subscribe(SparkTags.SecuritiesTag) + .Select(map => new FilteredDictionary(map, smd => smd.security.ContractCase == Security.ContractOneofCase.Synthetic)) + .Table(smd => smd.security.Id); + + var synthetic_user_join = synthetic_source.LeftJoin( + admin_model.all_user_tuples, + SecurityMD.key_fn, + UserTuple.key_fn, + smd => smd.security.Synthetic.UserId, + (smd, sid, ut, uid) => new SyntheticTuple(smd.security, ut.name, null), + (smd, sid, uid) => new SyntheticTuple(smd.security, null, null), + SyntheticTuple.key_fn); + + synthetic_tuples = synthetic_user_join.LeftJoin( + strategy_source, + SyntheticTuple.key_fn, + tup => tup.security_id, + (synth_tup, id, strat_tup) => new SyntheticTuple(synth_tup.security, synth_tup.user_name, strat_tup.strategy), + (synth_tup, id) => synth_tup, + SyntheticTuple.key_fn); } public IObservable> strategy => _bus.subscribe(SparkTags.SyntheticstrategiesTag); @@ -36,6 +64,8 @@ namespace mbts.spark { .LeftJoin(strategies, (security, strategy) => (new ExecutionStrategyImmutable?(strategy), security), security => (new ExecutionStrategyImmutable?(), security)) ); + public IObservable> synthetic_tuples { get; } + public IObservable security_strategy(uint security_key) => strategy.TrySelect(s => { bool success = s.TryGetValue(security_key, out ExecutionStrategyImmutable result); diff --git a/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs b/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs index 52458556b..cfbe2b7e3 100644 --- a/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs +++ b/src/client/spark/Modules/Spreader/SyntheticManagementWindow.cs @@ -10,6 +10,7 @@ using mbts.ui.utility; using mbts.utils; using System; using System.Collections.Generic; +using System.Collections.Immutable; using System.Linq; using System.Reactive.Linq; using System.Windows; @@ -27,7 +28,7 @@ namespace mbts.spark { readonly IWindowSettingsManager _settings_manager; - public SyntheticManagementWindow(SyntheticManagementWindowFactory factory, IBus bus, OrdersModel orders_model, StartupData state, WindowSettingsManager settings_manager) + public SyntheticManagementWindow(SyntheticManagementWindowFactory factory, IBus bus, OrdersModel orders_model, StartupData state, IWindowSettingsManager settings_manager) : base("Synthetic Management", bus, factory, SparkCommands.ShowSyntheticManagement.icon) { _orders_model = orders_model; _state = state; @@ -66,8 +67,8 @@ namespace mbts.spark { ), SparkCommand.create("Clone", Icons.CloneSynthetic, SparkTags.ShowSyntheticCloneTag).complete( current_row_connectable_builder.create(observe_row_strategy), rs => rs.HasValue, select_row_strategy_tuple - ), SparkCommands.ShowLadder(SparkCommands.KeyGestures.ShowLadder).complete( - vm_connectable_builder.create(vm => vm.current_security_md), md => md.HasValue, ConvertUtils.ValueOrDefault + ), SparkCommands.ShowLadderAutoLookup(SparkCommands.KeyGestures.ShowLadder).complete( + vm_connectable_builder.create(vm => vm.current_security_observable.Select(s => s.HasValue ? ImmutableHashSet.Empty.Add(s.Value.Id) : null)), id => id != null ), SparkCommands.ShowOrders.complete(() => { var ob_settings = bts.shell.orderbook.OrderBookStartupData.Default; ob_settings.filters = new bts.shell.orderbook.FilterStates { diff --git a/src/client/spark/Modules/Spreader/VM/SyntheticManagementDialogVM.cs b/src/client/spark/Modules/Spreader/VM/SyntheticManagementDialogVM.cs index c6dd59102..135f083e6 100644 --- a/src/client/spark/Modules/Spreader/VM/SyntheticManagementDialogVM.cs +++ b/src/client/spark/Modules/Spreader/VM/SyntheticManagementDialogVM.cs @@ -1,4 +1,5 @@ -using bts.api; +using bts; +using bts.api; using bts.collections; using bts.spark; using mbts.persist; @@ -7,6 +8,7 @@ using mbts.ui; using mbts.ui.settings; using System; using System.Collections.Generic; +using System.Collections.Immutable; using System.Collections.ObjectModel; using System.Linq; using System.Reactive.Linq; @@ -17,7 +19,7 @@ using static mbts.ui.controls.DIYGrid; using static mbts.ui.spark.SyntheticManagementView; namespace mbts.spark { - class SyntheticManagementDialogVM : SecurityMDGrid { + class SyntheticManagementDialogVM : SecurityGrid { readonly IBus _bus; readonly OrdersModel _orders_model; IWindowSettingsManager _settings_manager; @@ -25,7 +27,7 @@ namespace mbts.spark { public SyntheticManagementDialogVM(IBus bus, OrdersModel orders_model, IWindowSettingsManager settings_manager) : this(bus, orders_model, settings_manager, null, null) { } public SyntheticManagementDialogVM(IBus bus, OrdersModel orders_model, IWindowSettingsManager settings_manager, IReadOnlyCollection sorting, FilterStates filters) - : base(orders_model.spreader.strategy_tuple.Select(map => map.Values), sorting) { + : base(orders_model.spreader.synthetic_tuples.Select(t => t.state.Values), sorting) { _bus = bus; _orders_model = orders_model; if (filters != null) { @@ -73,8 +75,8 @@ namespace mbts.spark { ); } - protected override Row row_factory((ExecutionStrategyImmutable? strategy, SecurityMD md) row_model) => - new Row(_bus, row_model.md, row_model.strategy, _orders_model); + protected override Row row_factory(SyntheticTuple row_model) => + new Row(_bus, row_model, _orders_model); protected override void on_row_removed(Row row) => row.Dispose(); @@ -111,15 +113,15 @@ namespace mbts.spark { }; #endregion - public class Row : SecurityMDRow, IEquatable, IRowVM, IActionableRowVM { - public readonly ExecutionStrategyImmutable? strategy; + public class Row : SecurityRow, IEquatable, IRowVM, IActionableRowVM { + public readonly SyntheticTuple synthetic_tuple; readonly IBus _bus; readonly Property _n_working_orders; - public Row(IBus bus, SecurityMD security_md, ExecutionStrategyImmutable? strategy, OrdersModel orders_model) : base(security_md) { + public Row(IBus bus, SyntheticTuple synthetic_tuple, OrdersModel orders_model) : base(synthetic_tuple.security) { _bus = bus; - this.strategy = strategy; + this.synthetic_tuple = synthetic_tuple; _n_working_orders = backing(nameof(n_working_orders), orders_model.on_security_orders(security_key) .Select(t => (uint)(t.state @@ -137,6 +139,7 @@ namespace mbts.spark { public string name { get; } public int n_legs { get; } public string description { get; } + public ExecutionStrategyImmutable? strategy => synthetic_tuple.strategy; public bool strategy_present => strategy.HasValue; public uint n_working_orders => _n_working_orders.Value; public ICommand show_ladder { get; } @@ -166,7 +169,7 @@ namespace mbts.spark { void _show_ladder() => - _bus.post(SparkTags.ShowLadderTag, md); + _bus.post(SparkTags.ShowLadderAutoLookupTag, ImmutableHashSet.Empty.Add(security.Id)); void _show_order_book() { var ob_settings = bts.shell.orderbook.OrderBookStartupData.Default; diff --git a/src/client/spark/core/data/SyntheticTuple.cs b/src/client/spark/core/data/SyntheticTuple.cs new file mode 100644 index 000000000..b0717f1b5 --- /dev/null +++ b/src/client/spark/core/data/SyntheticTuple.cs @@ -0,0 +1,46 @@ +using bts.api; +using bts.spark; +using bts.utils; +using System; + +namespace bts { + struct SyntheticTuple : IEquatable, IComparable, IComparable { + public static readonly Func key_fn = a => a.security.Id; + public static readonly Func nullable_key_fn = a => a.HasValue ? a.Value.security.Id : 0u; + + public readonly SecurityImmutable security; + public readonly string user_name; + public readonly ExecutionStrategyImmutable? strategy; + public readonly int? num_working_orders; + + public SyntheticTuple(SecurityImmutable security, string user_name, ExecutionStrategyImmutable? strategy, int? num_working_orders = null) { + this.security = security; + this.user_name = user_name; + this.strategy = strategy; + this.num_working_orders = num_working_orders; + } + + public int CompareTo(SyntheticTuple other) => + SecurityHelper.Comparer.Compare(security, other.security); + + int IComparable.CompareTo(object obj) => + obj is SyntheticTuple other ? CompareTo(other) : 1; + + public bool Equals(SyntheticTuple other) => + security == other.security && + user_name == other.user_name && + EqualityComparer.nullable_equals(strategy, other.strategy); + + public override bool Equals(object obj) => + EqualityComparer.equals_obj(this, obj); + + public override int GetHashCode() => + security.Id.GetHashCode(); + + public override string ToString() => + user_name == null ? security.ToString() : $"{user_name}:{security}"; + + public static bool operator ==(SyntheticTuple a, SyntheticTuple b) => a.Equals(b); + public static bool operator !=(SyntheticTuple a, SyntheticTuple b) => !a.Equals(b); + } +}