public MainViewModel()
{
this.refreshCommand = ReactiveCommand.Create(PerformRefresh);
IObservable <Func <Plane, bool> > filter = this.WhenAnyValue(vm => vm.SearhText)
.Throttle(TimeSpan.FromMilliseconds(800))
.Select(BuildFilter);
IObservable <SortExpressionComparer <Plane> > sort = this.WhenAnyValue(vm => vm.SortDescending)
.Select(sd =>
{
if (sd)
{
return(SortExpressionComparer <Plane> .Descending(l => l.Name));
}
return(SortExpressionComparer <Plane> .Ascending(l => l.Name));
});
this.planes.Connect()
.Filter(filter)
.Sort(sort)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out this.bindingData)
.DisposeMany()
.Subscribe();
}
private void CreateSuggestions(int topSuggestionsCount)
{
var suggestionLabelsFilter = this.WhenAnyValue(x => x.Labels).Select(_ => Unit.Default)
.Merge(Observable.FromEventPattern(Labels, nameof(Labels.CollectionChanged)).Select(_ => Unit.Default))
.Select(_ => SuggestionLabelsFilter());
_sourceLabels
.Connect()
.Filter(suggestionLabelsFilter)
.Sort(SortExpressionComparer <SuggestionLabelViewModel> .Descending(x => x.Count).ThenByAscending(x => x.Label))
.Top(topSuggestionsCount)
.Transform(x => x.Label)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(_topSuggestions)
.Subscribe();
_sourceLabels
.Connect()
.Filter(suggestionLabelsFilter)
.Sort(SortExpressionComparer <SuggestionLabelViewModel> .Descending(x => x.Count).ThenByAscending(x => x.Label))
.Transform(x => x.Label)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(_suggestions)
.Subscribe();
Func <SuggestionLabelViewModel, bool> SuggestionLabelsFilter() => suggestionLabel => !_labels.Contains(suggestionLabel.Label);
}
public QueuesViewModel(IParameterViewStackService parameterViewStackService, IQueueService queueService)
: base(parameterViewStackService)
{
_queueService = queueService;
_queueService
.Queue
.Connect()
.RefCount()
.Transform(x => new QueuedItemViewModel(x))
.AutoRefresh(x => x.CurrentQueueTime)
.Sort(SortExpressionComparer <QueuedItemViewModel> .Descending(x => x.CurrentQueueTime))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _queue)
.DisposeMany()
.Subscribe()
.DisposeWith(Subscriptions);
Observable
.Interval(TimeSpan.FromSeconds(5))
.Subscribe(_ => _queueService.GetQueue(Guid.Empty))
.DisposeWith(Subscriptions);
InitializeData = ReactiveCommand.CreateFromObservable(ExecuteInitializeData);
}
public RecentFilesViewModel(IRecentFileCollection recentFileCollection, ISchedulerProvider schedulerProvider)
{
_recentFileCollection = recentFileCollection;
if (recentFileCollection == null)
{
throw new ArgumentNullException(nameof(recentFileCollection));
}
if (schedulerProvider == null)
{
throw new ArgumentNullException(nameof(schedulerProvider));
}
ReadOnlyObservableCollection <RecentFileProxy> data;
var recentLoader = recentFileCollection.Items
.Connect()
.Transform(rf => new RecentFileProxy(rf, toOpen =>
{
_fileOpenRequest.OnNext(new FileInfo(toOpen.Name));
},
recentFileCollection.Remove))
.Sort(SortExpressionComparer <RecentFileProxy> .Descending(proxy => proxy.Timestamp))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out data)
.Subscribe();
Files = data;
_cleanUp = Disposable.Create(() =>
{
recentLoader.Dispose();
_fileOpenRequest.OnCompleted();
});
}
public QueryHistoryProvider()
{
_historySourceList = new SourceList <RawQueryHistory>();
var counter = _historySourceList.CountChanged.Subscribe(i => IsEmpty = i == 0);
var limiter = _historySourceList.LimitSizeTo(100).Subscribe();
_historySourceList.AddRange(LoadFileData());
var sharedList = _historySourceList
.Connect()
.DeferUntilLoaded()
.Sort(SortExpressionComparer <RawQueryHistory> .Descending(t => t.LastRunAt))
.ObserveOnDispatcher()
.Bind(out _queryHistories)
.Subscribe();
var disposable = _queryHistories
.ObserveCollectionChanges()
.Throttle(TimeSpan.FromSeconds(2))
.Subscribe(pattern => { SaveFileData(_queryHistories); });
_compositeDisposable = new CompositeDisposable(counter, limiter, sharedList, disposable);
}
public PullRequestViewModel()
{
_cacheService = Locator.Current.GetService <ICacheService>();
_pullRequestData = new SourceList <LocalPullRequest>();
ItemTreshold = -1;
OpenCount = "0 opened";
CloseCount = "0 closed";
_pullRequestData.Connect()
.Sort(SortExpressionComparer <LocalPullRequest> .Descending(x => x.Date))
.ObserveOn(RxApp.MainThreadScheduler)
.Do(x => Count())
.Bind(out _pullRequests)
.DisposeMany().Subscribe();
ConfigureAddCommand();
ConfigureLoadCommand();
ConfigureLoadCacheCommand();
this.WhenAnyValue(x => x.Repository)
.Where(x => x != null)
.Select(x => Unit.Default)
.InvokeCommand(LoadCacheCommand);
}
public InfiniteScrollViewModel(IInventoryDataService inventoryDataService)
{
_inventoryDataService = inventoryDataService;
_pagingSubject = new BehaviorSubject <IPageRequest>(new PageRequest(0, pageSize));
Func <InventoryItemViewModel, bool> Search(string searchTerm) =>
viewModel =>
{
if (string.IsNullOrEmpty(searchTerm))
{
return(true);
}
var lower = searchTerm.ToLower();
return(viewModel.Brand.ToLower().Contains(lower) || (viewModel.Coffee?.ToLower().Contains(lower) ?? false));
};
var searchChanged =
this.WhenAnyValue(x => x.SearchText)
.Throttle(TimeSpan.FromMilliseconds(800), RxApp.TaskpoolScheduler)
.DistinctUntilChanged()
.Select(Search);
_inventoryDataService
.ChangeSet
.Transform(x =>
new InventoryItemViewModel
{
Id = x.Id,
Brand = x.BrandName,
Coffee = x.CoffeeName,
Roast = x.Roast,
Packaging = x.Packaging
})
.AutoRefresh(x => x.Id)
.DeferUntilLoaded()
.Filter(searchChanged)
.Sort(SortExpressionComparer <InventoryItemViewModel> .Descending(x => x.Roast))
.Page(_pagingSubject.AsObservable())
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _items)
.DisposeMany()
.Subscribe()
.DisposeWith(Garbage);
this.WhenAnyObservable(x => x.Refresh.IsExecuting)
.StartWith(false)
.DistinctUntilChanged()
.ToProperty(this, nameof(IsRefreshing), out _isRefreshing, deferSubscription: true)
.DisposeWith(Garbage);
this.WhenAnyObservable(x => x.Load.IsExecuting)
.ToProperty(this, nameof(IsLoading), out _isLoading, deferSubscription: true)
.DisposeWith(Garbage);
Refresh = ReactiveCommand.CreateFromObservable <EventArgs, Unit>(ExecuteRefresh);
Load = ReactiveCommand.CreateFromObservable <int, Unit>(ExecuteLoad);
_pagingSubject.DisposeWith(Garbage);
}
public PlaybackHistoryViewModel(
PlaybackHistory playbackHistory
//IAudioPlaybackEngine audioPlaybackEngine
//, IReadLibraryService readLibraryService
)
{
//this._audioPlayer = audioPlaybackEngine ?? throw new ArgumentNullException(nameof(audioPlaybackEngine));
//this._readLibraryService = readLibraryService ?? throw new ArgumentNullException(nameof(readLibraryService));
this._playbackHistory = playbackHistory ?? throw new ArgumentNullException(nameof(playbackHistory));
var sorter = SortExpressionComparer <PlaybackHistoryEntryViewModel> .Descending(pheVM => pheVM.PlaybackEndedDateTime);
//var sorter2 = new SortExpressionComparer<PlaybackHistoryEntryViewModel>();
this._playbackHistory.Entries
.Connect()
.Transform(phe => new PlaybackHistoryEntryViewModel(phe))
.DisposeMany()
.Sort(
SortExpressionComparer <PlaybackHistoryEntryViewModel> .Descending(pheVM => pheVM.PlaybackEndedDateTime),
SortOptions.UseBinarySearch)
.Bind(out var boundEntries)
.Subscribe()
.DisposeWith(this._disposables);
this.Entries = boundEntries;
// .WhenAudioSourceLocationChanged
// .ToObservableChangeSet(10)
// .Transform(location => new PlaybackHistoryItemViewModel(location))
// .Bind(out this._items)
// .DisposeMany()
// .Subscribe()
// .DisposeWith(this._disposables);
}
public StartPageViewModel(
IDatabaseInteractions databaseInteractions,
IApplicationInteraction applicationInteraction,
IRecentDatabaseFilesProvider recentDatabaseFilesProvider)
{
_databaseInteractions = databaseInteractions;
_applicationInteraction = applicationInteraction;
PathDefinitions = recentDatabaseFilesProvider;
ShowStartPageOnOpen = Properties.Settings.Default.ShowStartPageOnOpen;
var recentFilesTermFilter = this.WhenValueChanged(vm => vm.SearchTerm)
.Throttle(TimeSpan.FromMilliseconds(150))
.Select(CreatePredicate);
_cleanUp = PathDefinitions.RecentFiles
.ToObservableChangeSet()
.Filter(recentFilesTermFilter)
.Sort(
SortExpressionComparer <RecentDatabaseFileInfo>
.Descending(p => p.FixedAt.HasValue)
.ThenByDescending(p => p.FixedAt ?? p.LastOpenedAt)
)
.ObserveOnDispatcher()
.Bind(out _recentFilesFiltered)
.Do(p =>
{
NotifyOfPropertyChange(nameof(RecentFilesListIsEmpty));
NotifyOfPropertyChange(nameof(RecentFilesListEmptyMessage));
})
.Subscribe();
}
public void ResortOnInlineChanges()
{
var people = _generator.Take(10).ToList();
_source.AddRange(people);
people[0].Age = -1;
people[1].Age = -10;
people[2].Age = -12;
people[3].Age = -5;
people[4].Age = -7;
people[5].Age = -6;
var comparer = SortExpressionComparer <Person> .Descending(p => p.Age)
.ThenByAscending(p => p.Name);
_changeComparer.OnNext(comparer);
var expectedResult = people.OrderBy(p => p, comparer).ToArray();
var actualResult = _results.Data.Items.ToArray();
//actualResult.(expectedResult);
actualResult.ShouldAllBeEquivalentTo(expectedResult);
}
public void ResortOnInlineChanges()
{
var people = _generator.Take(10).ToList();
_source.AddRange(people);
people[0].Age = -1;
people[1].Age = -10;
people[2].Age = -12;
people[3].Age = -5;
people[4].Age = -7;
people[5].Age = -6;
var comparer = SortExpressionComparer <Person>
.Descending(p => p.Age)
.ThenByAscending(p => p.Name);
_changeComparer.OnNext(comparer);
//Assert.AreEqual(10, _results.Data.Count, "Should be 99 people in the cache");
//Assert.AreEqual(2, _results.Messages.Count, "Should be 2 update messages");
////Assert.AreEqual(toRemove, _results.Messages[1].First().Item.Current, "Incorrect item removed");
var expectedResult = people.OrderBy(p => p, comparer).ToArray();
var actualResult = _results.Data.Items.ToArray();
//actualResult.(expectedResult);
CollectionAssert.AreEqual(expectedResult, actualResult);
}
public HomeViewModel(ICacheService cacheService = null)
{
_cacheService = cacheService ?? Locator.Current.GetService <ICacheService>();
_repositoriesData = new SourceList <LocalRepository>();
ItemTreshold = -1;
ConfigureAddCommand();
ConfigureLoadCommand();
var filter = this.WhenAnyValue(x => x.Search)
.Throttle(TimeSpan.FromMilliseconds(500))
.Select(BuildFilter);
_repositoriesData.Connect()
.Filter(filter)
.Sort(SortExpressionComparer <LocalRepository> .Descending(x => x.StarsCount))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _repositories)
.DisposeMany().Subscribe();
this.WhenAnyValue(x => x.Selected)
.Where(x => x != null)
.Do(x => _cacheService.SetCurrentRepository(x))
.Subscribe();
Observable.FromEventPattern(
x => _cacheService.LanguageChanged += x,
x => _cacheService.LanguageChanged -= x)
.Do(x => _repositoriesData.Clear())
.Select(x => Unit.Default)
.InvokeCommand(LoadCache);
}
public SteamAccountPageViewModel()
{
IconKey = nameof(SteamAccountPageViewModel);
this.WhenAnyValue(x => x.SteamUsers)
.Subscribe(s => this.RaisePropertyChanged(nameof(IsUserEmpty)));
LoginAccountCommand = ReactiveCommand.Create(LoginNewSteamAccount);
RefreshCommand = ReactiveCommand.Create(Initialize);
ShareManageCommand = ReactiveCommand.Create(OpenShareManageWindow);
OpenBrowserCommand = ReactiveCommand.CreateFromTask <string>(Browser2.OpenAsync);
//MenuItems = new ObservableCollection<MenuItemViewModel>()
//{
// new MenuItemViewModel (nameof(AppResources.Refresh))
// { IconKey="RefreshDrawing" , Command = RefreshCommand},
// new MenuItemSeparator (),
// new MenuItemViewModel(nameof(AppResources.UserChange_LoginNewAccount))
// { IconKey="SteamDrawing", Command=LoginAccountCommand },
// new MenuItemViewModel(nameof(AppResources.AccountChange_Title)){
// IconKey ="ChannelShareDrawing", Command = ShareManageCommand },
// //new MenuItemViewModel(nameof(AppResources.UserChange_RemarkReplaceName)){
// // IconKey ="EditDrawing", Command = ShareManageCommand },
//};
_SteamUsersSourceList = new SourceCache <SteamUser, long>(t => t.SteamId64);
_SteamUsersSourceList
.Connect()
.ObserveOn(RxApp.MainThreadScheduler)
.Sort(SortExpressionComparer <SteamUser> .Descending(x => x.LastLoginTime))
.Bind(out _SteamUsers)
.Subscribe();
}
protected override IObservable <IChangeSet <GroupedData <DateTime, AudioItem> > > GetObservableChangeSet()
{
return(ItemsSource
.Connect()
.Sort(SortExpressionComparer <AudioItem> .Descending(x => x.CreatedDateUtc))
.GroupOn(x => x.CreatedDateUtc.Date)
.Transform(CreateAudioItemGroup));
}
public DisplaySetup()
{
_windows.Connect()
.Sort(SortExpressionComparer <ProcessWindow> .Descending(window => window.ZOrder))
.ObserveOnDispatcher()
.Bind(out var rooc).Subscribe();
Windows = rooc;
}
public SortDynamicDataViewModel()
{
this.WhenActivated((CompositeDisposable disposables) =>
{
_searchResultSource = new SourceList <RssEntry>().DisposeWith(disposables);
var sorter =
this.WhenAnyValue(x => x.SelectedSortType)
.Select(
SelectedSortType =>
{
switch (SelectedSortType)
{
case SortType.DateTimeAscending:
return(SortExpressionComparer <RssEntry> .Ascending(x => x.Updated));
case SortType.DateTimeDescending:
return(SortExpressionComparer <RssEntry> .Descending(x => x.Updated));
case SortType.TitleAscending:
return(SortExpressionComparer <RssEntry> .Ascending(x => x.Title));
case SortType.TitleDescending:
default:
return(SortExpressionComparer <RssEntry> .Descending(x => x.Title));
}
});
_searchResultSource
.Connect()
.SubscribeOn(RxApp.TaskpoolScheduler)
.Sort(sorter)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out var searchResultsBinding)
.Subscribe()
.DisposeWith(disposables);
this.SearchResults = searchResultsBinding;
Search =
ReactiveCommand
.CreateFromTask(
async(ct) =>
{
var worldNews = await RssDownloader.DownloadRss("https://www.reddit.com/r/worldnews/new/.rss", ct).ConfigureAwait(false);
_searchResultSource
.Edit(
innerList =>
{
innerList.Clear();
innerList.AddRange(worldNews);
});
})
.DisposeWith(disposables);
});
}
public HistoryViewModel(WalletViewModel walletViewModel, IObservable <Unit> updateTrigger)
{
_walletViewModel = walletViewModel;
_updateTrigger = updateTrigger;
_transactionSourceList = new SourceList <HistoryItemViewModelBase>();
_transactions = new ObservableCollectionExtended <HistoryItemViewModelBase>();
_unfilteredTransactions = new ObservableCollectionExtended <HistoryItemViewModelBase>();
this.WhenAnyValue(x => x.UnfilteredTransactions.Count)
.Subscribe(x => IsTransactionHistoryEmpty = x <= 0);
_transactionSourceList
.Connect()
.ObserveOn(RxApp.MainThreadScheduler)
.Sort(SortExpressionComparer <HistoryItemViewModelBase> .Descending(x => x.OrderIndex))
.Bind(_unfilteredTransactions)
.Bind(_transactions)
.Subscribe();
// [Column] [View] [Header] [Width] [MinWidth] [MaxWidth] [CanUserSort]
// Indicators IndicatorsColumnView - Auto 80 - false
// Date DateColumnView Date / Time Auto 150 - true
// Labels LabelsColumnView Labels * 75 - false
// Incoming IncomingColumnView Incoming (BTC) Auto 130 150 true
// Outgoing OutgoingColumnView Outgoing (BTC) Auto 130 150 true
// Balance BalanceColumnView Balance (BTC) Auto 130 150 true
Source = new HierarchicalTreeDataGridSource <HistoryItemViewModelBase>(_transactions)
{
Columns =
{
// Indicators
new HierarchicalExpanderColumn <HistoryItemViewModelBase>(
new TemplateColumn <HistoryItemViewModelBase>(
null,
new FuncDataTemplate <HistoryItemViewModelBase>((node,ns) => new IndicatorsColumnView(), true),
options: new ColumnOptions <HistoryItemViewModelBase>
{
CanUserResizeColumn = false,
CanUserSortColumn = true,
CompareAscending = HistoryItemViewModelBase.SortAscending(x => x.IsCoinJoin),
CompareDescending = HistoryItemViewModelBase.SortDescending(x => x.IsCoinJoin),
MinWidth = new GridLength(80, GridUnitType.Pixel)
},
width: new GridLength(0, GridUnitType.Auto)),
x => x.Children,
x =>
{
if (x is CoinJoinsHistoryItemViewModel coinJoinsHistoryItemViewModel &&
coinJoinsHistoryItemViewModel.CoinJoinTransactions.Count > 1)
{
return(true);
}
return(false);
},
public NearToMarketViewer(INearToMarketService nearToMarketService)
{
_cleanUp = nearToMarketService.Query(() => NearToMarketPercent)
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp))
.ObserveOnDispatcher()
.Bind(_data)
.DisposeMany()
.Subscribe();
}
public NearToMarketViewer(INearToMarketService nearToMarketService, ISchedulerProvider schedulerProvider, ILogger logger)
{
_cleanUp = nearToMarketService.Query(() => NearToMarketPercent)
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _data)
.DisposeMany()
.Subscribe(_ => {}, ex => logger.Error(ex, "Error in near to market viewer"));
}
public TimeLineViewModel(ITwitterService twitterService = null)
{
_twitterService = twitterService ?? Locator.Current.GetService <ITwitterService>();
_twitterService.Tweets.Connect()
.Transform(t => new TweetViewModel {
Tweet = t
})
.Sort(SortExpressionComparer <TweetViewModel> .Descending(c => c.Tweet.CreatedAt))
.Bind(out timeLine)
.DisposeMany().Subscribe();
}
public RecentTradesViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_cleanUp = tradeService.All.Connect()
.SkipInitial()
.ExpireAfter((trade) => TimeSpan.FromSeconds(30))
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
}
public TransactionsViewModel(IEthereumHostProvider ethereumHostProvider, CurrentAccountTransactionsService currentAccountTransactionsService)
{
this.currentAccountTransactionsService = currentAccountTransactionsService;
this.currentAccountTransactionsService.Transactions.Connect()
.Transform(transaction => new TransactionViewModel(transaction))
.AutoRefresh()
.Sort(SortExpressionComparer <TransactionViewModel> .Descending(t => t.Status).ThenByDescending(t => t.BlockNumber))
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _transactions)
.DisposeMany()
.Subscribe();
}
public TradesByTime([NotNull] IGroup <Trade, long, TimePeriod> group,
ISchedulerProvider schedulerProvider)
{
Period = group?.Key ?? throw new ArgumentNullException(nameof(group));
_cleanUp = group.Cache.Connect()
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer <TradeProxy> .Descending(p => p.Timestamp), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _data)
.DisposeMany()
.Subscribe();
}
public void Reset()
{
var people = Enumerable.Range(1, 100).Select(i => new Person("P" + i, i)).OrderBy(x => Guid.NewGuid()).ToArray();
_cache.AddOrUpdate(people);
_sortController.Change(SortExpressionComparer <Person> .Descending(p => p.Age));
_sortController.Reset();
var expectedResult = people.OrderBy(p => p, _comparer).Select(p => new KeyValuePair <string, Person>(p.Name, p)).ToList();
var actualResult = _results.Messages[2].SortedItems.ToList();
actualResult.ShouldAllBeEquivalentTo(expectedResult);
}
public void Reset()
{
var people = Enumerable.Range(1, 100).Select(i => new Person("P" + i, i)).OrderBy(x => Guid.NewGuid()).ToArray();
_cache.AddOrUpdate(people);
_comparerObservable.OnNext(SortExpressionComparer <Person> .Descending(p => p.Age));
_comparerObservable.OnNext(_comparer);
var expectedResult = people.OrderBy(p => p, _comparer).Select(p => new KeyValuePair <string, Person>(p.Name, p)).ToList();
var actualResult = _results.Messages[2].SortedItems.ToList();
CollectionAssert.AreEquivalent(expectedResult, actualResult);
}
private bool _disposedValue = false; // To detect redundant calls
public LoadWalletViewModel(WalletManagerViewModel owner, LoadWalletType loadWalletType)
: base(loadWalletType == LoadWalletType.Password ? "Test Password" : "Load Wallet")
{
Global = Locator.Current.GetService <Global>();
Owner = owner;
Password = "";
LoadWalletType = loadWalletType;
this.ValidateProperty(x => x.Password, ValidatePassword);
RootList = new SourceList <WalletViewModelBase>();
RootList.Connect()
.AutoRefresh(model => model.WalletState)
.Filter(x => (!IsPasswordRequired || !x.Wallet.KeyManager.IsWatchOnly))
.Sort(SortExpressionComparer <WalletViewModelBase>
.Descending(p => p.Wallet.KeyManager.GetLastAccessTime()),
resort: ResortTrigger.AsObservable())
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out _wallets)
.DisposeMany()
.Subscribe()
.DisposeWith(Disposables);
Observable.FromEventPattern <Wallet>(Global.WalletManager, nameof(Global.WalletManager.WalletAdded))
.ObserveOn(RxApp.MainThreadScheduler)
.Select(x => x.EventArgs)
.Subscribe(wallet => RootList.Add(new WalletViewModelBase(wallet)))
.DisposeWith(Disposables);
this.WhenAnyValue(x => x.SelectedWallet)
.Where(x => x is null)
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(_ => SelectedWallet = Wallets.FirstOrDefault());
Wallets
.ToObservableChangeSet()
.ToCollection()
.Where(items => items.Any() && SelectedWallet is null)
.Select(items => items.First())
.ObserveOn(RxApp.MainThreadScheduler)
.Subscribe(x => SelectedWallet = x);
LoadCommand = ReactiveCommand.Create(() =>
RxApp.MainThreadScheduler
.Schedule(async() => await LoadWalletAsync())
.DisposeWith(Disposables),
this.WhenAnyValue(x => x.SelectedWallet, x => x?.WalletState)
.Select(x => x == WalletState.Uninitialized));
TestPasswordCommand = ReactiveCommand.Create(LoadKeyManager, this.WhenAnyValue(x => x.SelectedWallet).Select(x => x is { }));
public MixerVM([NotNull] MixPalette palette, List <MixtureItemVM> mixture = null)
{
var percentSubject = new Subject <double>();
OK = CreateCommand(() => DialogResult = true);
PaletteName = palette.Name;
Components = new ObservableCollection <MixComponent>(palette.Components);
var percentObs = percentSubject.Delay(TimeSpan.FromMilliseconds(300))
.Throttle(TimeSpan.FromMilliseconds(300))
.ObserveOnDispatcher()
.Select(_ => Unit.Default);
percentObs.Subscribe(s => CalcPercent());
var mixtureSrc = new SourceList <MixtureItemVM>();
mixtureSrc.Connect()
.Sort(SortExpressionComparer <MixtureItemVM> .Descending(i => i.Percent), resort: percentObs)
.ObserveOnDispatcher()
.Bind(out var mixtureData)
.Subscribe();
Mixture = mixtureData;
AddComponemt = CreateCommand <MixComponent>(c =>
{
if (mixtureSrc.Items.Any(m => m.Component == c))
{
return;
}
Components.Remove(c);
var item = new MixtureItemVM {
Component = c
};
item.WhenAnyValue(v => v.Percent).Skip(1).Subscribe(s =>
percentSubject.OnNext(s));
mixtureSrc.Add(item);
CalcPercent();
});
DeleteComponent = CreateCommand <MixtureItemVM>(c =>
{
mixtureSrc.Remove(c);
Components.Add(c.Component);
CalcPercent();
});
if (mixture?.Any() == true)
{
mixture.ToObservable().InvokeCommand(AddComponemt);
}
}
public ExchangeAccountViewModel(ExchangeAccount acc)
{
Account = acc;
Account.Deposits.Connect()
.Sort(SortExpressionComparer <Transfer> .Descending(x => x.Timestamp))
.ObserveOnDispatcher()
.Bind(out deposits)
.Subscribe()
.DisposeWith(disposables);
Account.Withdrawals.Connect()
.Sort(SortExpressionComparer <Transfer> .Descending(x => x.Timestamp))
.ObserveOnDispatcher()
.Bind(out withdrawals)
.Subscribe()
.DisposeWith(disposables);
Account.OpenOrders.Connect()
.Sort(SortExpressionComparer <Order> .Descending(x => x.Created))
.ObserveOnDispatcher()
.Bind(out openOrders)
.Subscribe()
.DisposeWith(disposables);
Account.OrdersHistory.Connect()
.Sort(SortExpressionComparer <Order> .Descending(x => x.Created))
.Filter(x => CancelledOrdersVisible || x.Status != OrderStatus.Cancelled)
.ObserveOnDispatcher()
.Bind(out ordersHistory)
.Subscribe()
.DisposeWith(disposables);
Account.TradesHistory.Connect()
.Sort(SortExpressionComparer <OrderTrade> .Descending(x => x.Timestamp))
.ObserveOnDispatcher()
.Bind(out tradesHistory)
.Subscribe()
.DisposeWith(disposables);
Account.BalanceManager.Balances.Connect()
.Sort(SortExpressionComparer <Balance> .Ascending(x => x.Asset))
.ObserveOnDispatcher()
.Bind(out balances)
.Subscribe()
.DisposeWith(disposables);
this.WhenAnyValue(x => x.Account.BalanceManager.TotalBtc)
.ToPropertyEx(this, vm => vm.TotalBtc);
this.WhenAnyValue(x => x.Account.BalanceManager.TotalUsd)
.ToPropertyEx(this, vm => vm.TotalUsd);
}
public void ChangeSort()
{
var people = _generator.Take(100).ToArray();
_cache.AddOrUpdate(people);
var desc = SortExpressionComparer <Person> .Descending(p => p.Age).ThenByAscending(p => p.Name);
_comparerObservable.OnNext(desc);
var expectedResult = people.OrderBy(p => p, desc).Select(p => new KeyValuePair <string, Person>(p.Name, p)).ToList();
var actualResult = _results.Messages[0].SortedItems.ToList();
CollectionAssert.AreEquivalent(expectedResult, actualResult);
}
/// <summary>
/// Initializes a new instance of the <see cref="TagViewModel"/> class.
/// </summary>
public TagViewModel()
{
IObservable <bool> isValidRepository = this.WhenAnyValue(x => x.RepositoryDetails).Select(details => details != null);
this.refresh = ReactiveCommand.CreateFromObservable(this.RefreshImpl, isValidRepository);
this.refresh.ToObservableChangeSet()
.Sort(SortExpressionComparer <GitTag> .Descending(p => p.DateTime), SortOptions.UseBinarySearch)
.ObserveOn(RxApp.MainThreadScheduler)
.Bind(out this.tags)
.Subscribe();
this.selectedGitTag = this.WhenAnyValue(x => x.SelectedGitObject).Select(x => x as GitTag).ToProperty(this, x => x.SelectedTag, out this.selectedGitTag);
}
