90 lines
4.3 KiB
C#
90 lines
4.3 KiB
C#
using bts;
|
|
using bts.api;
|
|
using bts.api.admin;
|
|
using bts.api.core;
|
|
using bts.collections;
|
|
using bts.utils;
|
|
|
|
using Spark.Core.Disposables;
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Composition;
|
|
using System.Linq;
|
|
using System.Reactive.Linq;
|
|
|
|
namespace mbts.spark {
|
|
[Export]
|
|
class AdminModel : IDisposable {
|
|
public readonly UserTuple user;
|
|
|
|
IDisposable _dispose;
|
|
IReadOnlyDictionary<uint, string> _account_map = DictionaryHelper.empty<uint, string>();
|
|
|
|
[ImportingConstructor]
|
|
public AdminModel(IBus bus, AdminService service, Lazy<UserTuple> user)
|
|
: this(bus, service, user.Value) { }
|
|
|
|
AdminModel(IBus bus, AdminService service, UserTuple user) {
|
|
this.user = user;
|
|
// accounts
|
|
on_accounts = service.subscribei_admin_data()
|
|
.Select(up => up.all.TryGetFirst(out var ad) && ad.Users.Where(u => u.Name == user.name).TryGetSingle(out var usr) && usr.HasUserData && usr.UserData.HasAccountPermissions ?
|
|
usr.UserData.AccountPermissions.AccountPermissions
|
|
.Where(kv => (kv.Value.TradingPermission != null && kv.Value.TradingPermission.HasPermissions) || kv.Value.AdminPermission.HasPermissions)
|
|
.Select(kv => ad.Accounts.Where(a => a.Id == kv.Key).TryGetSingle(out var acc) ? acc : (BTSAccountImmutable?)null)
|
|
.Where(acc => acc.HasValue && acc.Value.IsPresent)
|
|
.Select(acc => acc.Value)
|
|
.ToDictionary(acc => acc.Id, acc => acc.Name) :
|
|
new Dictionary<uint, string>(0))
|
|
.Replay(1)
|
|
.RefCount();
|
|
// 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.FirstOrNull())
|
|
.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<UserTuple, uint>.mk_empty(UserTuple.key_fn).with_added(new[] { user }));
|
|
_dispose = Disposable.Create(
|
|
all_user_tuples.Subscribe(t => bus.post(SparkTags.Users, t.state)),
|
|
on_accounts.Subscribe(map => {
|
|
_account_map = map;
|
|
var account_tuple_map = MappedDictionary.create(map, (id, name) => new AccountTuple(id, name));
|
|
bus.post(SparkTags.AccountsTag, account_tuple_map);
|
|
}));
|
|
bus.post(SparkTags.CurrentUser, user);
|
|
}
|
|
|
|
public IObservable<IReadOnlyDictionary<uint, string>> on_users { get; }
|
|
public IObservable<IReadOnlyDictionary<uint, string>> on_accounts { get; }
|
|
public IObservable<TableUpdate<UserTuple, uint>> all_user_tuples { get; }
|
|
public IObservable<IReadOnlyList<AccountTuple>> on_account_tuples => on_accounts.Select(d => d.Select(kv => new AccountTuple(kv.Key, kv.Value)).ToListSorted(a => a.name));
|
|
|
|
public IObservable<Update<T, TKey>> permission_filter<T, TKey>(IObservable<Update<T, TKey>> positions, Func<T, uint> get_account_id) where TKey : IEquatable<TKey> =>
|
|
user.permissions == UserTuple.Permissions.Admin ?
|
|
positions :
|
|
positions.Filter(on_accounts.Select(map => new Func<T, bool>(p => map.ContainsKey(get_account_id(p)))));
|
|
|
|
public IObservable<Update<T, TKey>> permission_filter<T, TKey>(IObservable<Update<T, TKey>> positions, Func<T, string> get_account_name) where TKey : IEquatable<TKey> =>
|
|
user.permissions == UserTuple.Permissions.Admin ?
|
|
positions :
|
|
positions.Filter(on_accounts.Select(map => {
|
|
var hash = new HashSet<string>(map.Values);
|
|
return new Func<T, bool>(v => hash.Contains(get_account_name(v)));
|
|
}));
|
|
|
|
public AccountTuple? get_default_account() =>
|
|
_account_map.Select(kv => new AccountTuple(kv.Key, kv.Value)).FirstOrNull();
|
|
|
|
public void Dispose() =>
|
|
Disposable.dispose(ref _dispose);
|
|
}
|
|
}
|