From 478640e80845bfb43237a24d72537e6f1c1c8c19 Mon Sep 17 00:00:00 2001 From: John Colvin Date: Wed, 15 May 2019 12:24:34 -0500 Subject: [PATCH] ManualFillTuple join with account and user --- src/client/spark/Orders/OrdersModel.cs | 18 ++++++++ src/client/spark/core/data/AccountTuple.cs | 2 + src/client/spark/core/data/ManualFillTuple.cs | 41 +++++++++++++++++ src/client/spark/core/data/UserTuple.cs | 2 + .../spark_core/utils/MappedDictionary.cs | 45 +++++++++++++++++++ 5 files changed, 108 insertions(+) create mode 100644 src/client/spark/core/data/ManualFillTuple.cs diff --git a/src/client/spark/Orders/OrdersModel.cs b/src/client/spark/Orders/OrdersModel.cs index 026628697..0c1375d3d 100644 --- a/src/client/spark/Orders/OrdersModel.cs +++ b/src/client/spark/Orders/OrdersModel.cs @@ -142,6 +142,23 @@ namespace mbts.spark { .Naggle(interval, scheduler) .join(sstore, mf => mf.SecurityKey) .Table().Cache(); + var manual_fill_tuples_account_join = on_manual_fills_securities.LeftJoin( + admin_model.on_accounts.Select(d => MappedDictionary.create(d, kv => new AccountTuple(kv.Key, kv.Value))).Table(a => a.id), + mfs => mfs.Item2.RecordId, + AccountTuple.key_fn, + mfs => mfs.Item2.AccountId, + (mfs, mf_id, a, a_id) => new ManualFillTuple(mfs.Item2, mfs.Item1, a, null), + (mfs, mf_id, a_id) => new ManualFillTuple(mfs.Item2, mfs.Item1, null, null), + ManualFillTuple.key_fn); + on_manual_fill_tuples = manual_fill_tuples_account_join.LeftJoin( + admin_model.on_users.Select(d => MappedDictionary.create(d, kv => new UserTuple(kv.Key, kv.Value))).Table(a => a.id), + ManualFillTuple.key_fn, + UserTuple.key_fn, + mft => mft.manual_fill.UserId, + (mft, mft_id, u, u_id) => new ManualFillTuple(mft.manual_fill, mft.security, mft.account, u), + (mft, mft_id, u_id) => mft, + ManualFillTuple.key_fn) + .Cache(); // can attach on_orders_can_attach = on_orders.ParentDependent( t => t.order.Key, @@ -186,6 +203,7 @@ namespace mbts.spark { public IObservable> on_positions { get; } public IObservable> studio_algos_with_meta { get; } public IObservable> on_manual_fills_securities { get; } + public IObservable> on_manual_fill_tuples { get; } public AdminModel admin_model { get; } public IAlgoStudioModel algo_model { get; } diff --git a/src/client/spark/core/data/AccountTuple.cs b/src/client/spark/core/data/AccountTuple.cs index 2da797c88..dc29e8b1d 100644 --- a/src/client/spark/core/data/AccountTuple.cs +++ b/src/client/spark/core/data/AccountTuple.cs @@ -2,6 +2,8 @@ namespace bts { struct AccountTuple : IEquatable { + public static readonly Func key_fn = a => a.id; + public readonly uint id; public readonly string name; diff --git a/src/client/spark/core/data/ManualFillTuple.cs b/src/client/spark/core/data/ManualFillTuple.cs new file mode 100644 index 000000000..5c3dfd6b0 --- /dev/null +++ b/src/client/spark/core/data/ManualFillTuple.cs @@ -0,0 +1,41 @@ +using bts; +using bts.api; +using bts.api.position; +using bts.utils; +using System; + +namespace bts { + struct ManualFillTuple : IEquatable { + public static readonly Func key_fn = m => m.manual_fill.RecordId; + + public readonly ManualFillImmutable manual_fill; + public readonly SecurityImmutable? security; + public readonly AccountTuple? account; + public readonly UserTuple? user; + + public ManualFillTuple(ManualFillImmutable manual_fill, SecurityImmutable? security, AccountTuple? account, UserTuple? user) { + this.manual_fill = manual_fill; + this.security = security; + this.account = account; + this.user = user; + } + + public bool Equals(ManualFillTuple other) => + manual_fill.Equals(other.manual_fill) && + EqualityComparer.nullable_equals(security, other.security) && + EqualityComparer.nullable_equals(account, other.account) && + EqualityComparer.nullable_equals(user, other.user); + public override bool Equals(object obj) => + obj is ManualFillTuple other && Equals(other); + + public override int GetHashCode() => + EqualityComparer.aggregate_hash( + manual_fill.GetHashCode(), + security?.GetHashCode() ?? 0, + account?.GetHashCode() ?? 0, + user?.GetHashCode() ?? 0); + + public static bool operator ==(ManualFillTuple a, ManualFillTuple b) => a.Equals(b); + public static bool operator !=(ManualFillTuple a, ManualFillTuple b) => !a.Equals(b); + } +} \ No newline at end of file diff --git a/src/client/spark/core/data/UserTuple.cs b/src/client/spark/core/data/UserTuple.cs index 8ffe03fd1..16ae77c36 100644 --- a/src/client/spark/core/data/UserTuple.cs +++ b/src/client/spark/core/data/UserTuple.cs @@ -2,6 +2,8 @@ namespace bts { struct UserTuple : IEquatable { + public static readonly Func key_fn = u => u.id; + public readonly uint id; public readonly string name; diff --git a/src/client/spark_core/utils/MappedDictionary.cs b/src/client/spark_core/utils/MappedDictionary.cs index d66ce775f..0863b7df5 100644 --- a/src/client/spark_core/utils/MappedDictionary.cs +++ b/src/client/spark_core/utils/MappedDictionary.cs @@ -4,6 +4,51 @@ using System.Collections.Generic; using System.Linq; namespace bts.collections { + static class MappedDictionary { + public static IReadOnlyDictionary create(IReadOnlyDictionary source, Func map) => + new MappedDictionary(source, map); + + public static IReadOnlyDictionary create(IReadOnlyDictionary source, Func, TResult> map) => + new KeyValueWrapper(source, map); + + class KeyValueWrapper : IReadOnlyDictionary { + readonly IReadOnlyDictionary _source; + readonly Func, TResult> _map; + + public KeyValueWrapper(IReadOnlyDictionary source, Func, TResult> map) { + _source = source; + _map = map; + } + + public TResult this[TKey key] => _map(new KeyValuePair(key, _source[key])); + public IEnumerable Keys => _source.Keys; + + public IEnumerable Values { + get { + foreach (var kv in _source) + yield return _map(kv); + } + } + + public int Count => _source.Count; + + public bool ContainsKey(TKey key) => _source.ContainsKey(key); + public IEnumerator> GetEnumerator() { + foreach (var kv in _source) + yield return new KeyValuePair(kv.Key, _map(kv)); + } + public bool TryGetValue(TKey key, out TResult value) { + if (_source.TryGetValue(key, out var v)) { + value = _map(new KeyValuePair(key, v)); + return true; + } + value = default; + return false; + } + IEnumerator IEnumerable.GetEnumerator() => GetEnumerator(); + } + } + internal class MappedDictionary : IReadOnlyDictionary { readonly IReadOnlyDictionary _dict; readonly Func _map;