public TradeService(ILogger logger,TradeGenerator tradeGenerator, ISchedulerProvider schedulerProvider)
{
_logger = logger;
_tradeGenerator = tradeGenerator;
_schedulerProvider = schedulerProvider;
//construct a cache specifying that the primary key is Trade.Id
_tradesSource = new SourceCache<Trade, long>(trade => trade.Id);
//call AsObservableCache() to hide the update methods as we are exposing the cache
_all = _tradesSource.AsObservableCache();
//create a derived cache
_live = _tradesSource.Connect(trade => trade.Status == TradeStatus.Live).AsObservableCache();
//code to emulate an external trade provider
var tradeLoader = GenerateTradesAndMaintainCache();
//expire closed items from the cache ro avoid unbounded data
var expirer = _tradesSource
.ExpireAfter(t => t.Status == TradeStatus.Closed ? TimeSpan.FromMinutes(1) : (TimeSpan?)null,TimeSpan.FromMinutes(1),schedulerProvider.TaskPool)
.Subscribe(x=>_logger.Info("{0} filled trades have been removed from memory",x.Count()));
//log changes
var loggerWriter = LogChanges();
_cleanup = new CompositeDisposable(_all, _tradesSource, tradeLoader, loggerWriter, expirer);
}
public ImapClient(ISchedulerProvider schedulerProvider, ILoggerFactory loggerFactory)
{
//_dedicatedScheduler = schedulerProvider.CreateEventLoopScheduler("IMAP");
_dedicatedScheduler = schedulerProvider.Concurrent;
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger(GetType());
}
public SearchHints(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
//instaniate a filter controller so we can change the filter any time
var filter = new FilterController<string>();
//build a predicate when SeatchText changes
var filterApplier = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter)
.Subscribe(filter.Change);
//share the connection
var shared = tradeService.All.Connect().Publish();
//distinct list of customers
var customers = shared.DistinctValues(trade => trade.Customer);
//distinct list of currency pairs
var currencypairs = shared.DistinctValues(trade => trade.CurrencyPair);
//create single list of all customers all items in currency ypairs
var loader = customers.Or(currencypairs)
.Filter(filter) //filter strings
.Sort(SortExpressionComparer<string>.Ascending(str=>str))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _hints) //bind to hints list
.Subscribe();
_cleanUp = new CompositeDisposable(loader, filter, shared.Connect(), filterApplier);
}
public GeneralOptionsViewModel(ISetting<GeneralOptions> setting, ISchedulerProvider schedulerProvider)
{
var reader = setting.Value.Subscribe(options =>
{
UseDarkTheme = options.Theme== Theme.Dark;
HighlightTail = options.HighlightTail;
HighlightDuration = options.HighlightDuration;
Scale = options.Scale;
});
var writter = this.WhenAnyPropertyChanged()
.Subscribe(vm =>
{
setting.Write(new GeneralOptions(UseDarkTheme ? Theme.Dark : Theme.Light, HighlightTail, HighlightDuration, Scale));
});
HighlightDurationText = this.WhenValueChanged(vm=>vm.HighlightDuration)
.Select(value => value.ToString("0.00 Seconds"))
.ForBinding();
ScaleText = this.WhenValueChanged(vm => vm.Scale)
.Select(value => $"{value} %" )
.ForBinding();
ScaleRatio= this.WhenValueChanged(vm => vm.Scale)
.Select(value =>(decimal)value / (decimal)100)
// .Sample(TimeSpan.FromMilliseconds(250))
.ForBinding();
_cleanUp = new CompositeDisposable(reader, writter, HighlightDurationText, ScaleText, ScaleRatio);
}
public PagedDataViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
//build observable predicate from search text
var filter = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
//build observable sort comparer
var sort = SortParameters.WhenValueChanged(t => t.SelectedItem)
.Select(prop => prop.Comparer)
.ObserveOn(schedulerProvider.TaskPool);
//build observable comparer
var currentPageChanged = PageParameters.WhenValueChanged(p => p.CurrentPage);
var pageSizeChanged = PageParameters.WhenValueChanged(p => p.PageSize);
var pager = currentPageChanged.CombineLatest(pageSizeChanged,(page, size) => new PageRequest(page, size))
.StartWith(new PageRequest(1, 25))
.DistinctUntilChanged()
.Sample(TimeSpan.FromMilliseconds(100));
// filter, sort, page and bind to observable collection
_cleanUp = tradeService.All.Connect()
.Filter(filter) // apply user filter
.Transform(trade => new TradeProxy(trade), new ParallelisationOptions(ParallelType.Ordered, 5))
.Sort(sort, SortOptimisations.ComparesImmutableValuesOnly)
.Page(pager)
.ObserveOn(schedulerProvider.MainThread)
.Do(changes => _pageParameters.Update(changes.Response))
.Bind(out _data) // update observable collection bindings
.DisposeMany() // dispose when no longer required
.Subscribe();
}
public TailViewModelFactory([NotNull] IObjectProvider objectProvider,
[NotNull] ISchedulerProvider schedulerProvider,
[NotNull] IColourProvider colourProvider,
[NotNull] ISearchMetadataFactory searchMetadataFactory,
[NotNull] IIconProvider iconProvider,
[NotNull] ITailViewStateControllerFactory tailViewStateControllerFactory,
[NotNull] ITextAssociationCollection textAssociationCollection,
[NotNull] IThemeProvider themeProvider)
{
if (objectProvider == null) throw new ArgumentNullException(nameof(objectProvider));
if (schedulerProvider == null) throw new ArgumentNullException(nameof(schedulerProvider));
if (colourProvider == null) throw new ArgumentNullException(nameof(colourProvider));
if (searchMetadataFactory == null) throw new ArgumentNullException(nameof(searchMetadataFactory));
if (iconProvider == null) throw new ArgumentNullException(nameof(iconProvider));
if (tailViewStateControllerFactory == null)
throw new ArgumentNullException(nameof(tailViewStateControllerFactory));
_objectProvider = objectProvider;
_schedulerProvider = schedulerProvider;
_colourProvider = colourProvider;
_searchMetadataFactory = searchMetadataFactory;
_iconProvider = iconProvider;
_tailViewStateControllerFactory = tailViewStateControllerFactory;
_textAssociationCollection = textAssociationCollection;
_themeProvider = themeProvider;
}
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 void Setup()
{
_sparkCoreSettings = A.Fake<Configuration.ISparkCore>();
A.CallTo(() => _sparkCoreSettings.AccessToken).Returns("0123456789abcdef123456");
A.CallTo(() => _sparkCoreSettings.DefaultIndexName).Returns("CoreIndex");
A.CallTo(() => _sparkCoreSettings.DefaultInterval).Returns(TimeSpan.FromSeconds(100));
A.CallTo(() => _sparkCoreSettings.DefaultType).Returns("CoreType");
A.CallTo(() => _sparkCoreSettings.Devices).Returns(new[] { _deviceA, _deviceB });
_elasticSearchSettings = A.Fake<Configuration.IElasticSearch>();
A.CallTo(() => _elasticSearchSettings.Host).Returns("http://localhost:9220");
A.CallTo(() => _elasticSearchSettings.Indexes).Returns(new[] { _tempIndex, _humidityIndex, _lightIndex });
_settings = A.Fake<Configuration.ISettings>();
A.CallTo(() => _settings.SparkCore).Returns(_sparkCoreSettings);
A.CallTo(() => _settings.ElasticSearch).Returns(_elasticSearchSettings);
_sparkApi = A.Fake<Io.Spark.IApi>();
_documentFactory = A.Fake<Document.IFactory>();
_schedulerProvider = A.Fake<ISchedulerProvider>();
_testScheduler = new TestScheduler();
A.CallTo(() => _schedulerProvider.AsyncScheduler).Returns(_testScheduler);
_subject = new SparkSource(_settings, _sparkApi, _documentFactory, _schedulerProvider);
}
static PagesHandler()
{
CustomCssUrl = Configuration.ConfigUtils.CustomCssUrl;
SchedulerProvider = Configuration.ConfigUtils.SchedulerProvider;
SchedulerProvider.Init();
SchedulerDataProvider = new DefaultSchedulerDataProvider(SchedulerProvider);
}
public TradesByTimeViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_schedulerProvider = schedulerProvider;
var groupController = new GroupController();
var grouperRefresher = Observable.Interval(TimeSpan.FromSeconds(1))
.Subscribe(_ => groupController.RefreshGroup());
var loader = tradeService.Trades.Connect()
.Group(trade =>
{
var diff = DateTime.Now.Subtract(trade.Timestamp);
if (diff.TotalSeconds <= 60) return TimePeriod.LastMinute;
if (diff.TotalMinutes <= 60) return TimePeriod.LastHour;
return TimePeriod.Older;
}, groupController)
.Transform(group => new TradesByTime(group, _schedulerProvider))
.Sort(SortExpressionComparer<TradesByTime>.Ascending(t => t.Period))
.ObserveOn(_schedulerProvider.Dispatcher)
.Bind(_data)
.DisposeMany()
.Subscribe();
_cleanUp = new CompositeDisposable(loader, grouperRefresher);
}
public ProfileDashBoardViewModel(IProfileDashboard profileDashboard, ISchedulerProvider schedulerProvider)
{
_profileDashboard = profileDashboard;
_schedulerProvider = schedulerProvider;
_messages = new DashboardCollection<Message>(_profileDashboard.Messages.ObserveOn(_schedulerProvider.Dispatcher));
_pictureAlbums = new DashboardCollection<Album>(_profileDashboard.PictureAlbums.ObserveOn(_schedulerProvider.Dispatcher));
_calendarEvents = new DashboardCollection<ICalendarEvent>(_profileDashboard.CalendarEvents.ObserveOn(_schedulerProvider.Dispatcher));
}
public TailViewModelFactory([NotNull] IObjectProvider objectProvider, [NotNull] ISchedulerProvider schedulerProvider)
{
if (objectProvider == null) throw new ArgumentNullException(nameof(objectProvider));
if (schedulerProvider == null) throw new ArgumentNullException(nameof(schedulerProvider));
_objectProvider = objectProvider;
_schedulerProvider = schedulerProvider;
}
static PagesHandler()
{
ViewEngine = new VelocityViewEngine();
ViewEngine.Init();
SchedulerProvider = Configuration.ConfigUtils.SchedulerProvider;
SchedulerProvider.Init();
SchedulerDataProvider = new DefaultSchedulerDataProvider(SchedulerProvider);
}
public BluetoothDevice(IBluetoothDeviceInfo deviceInfo, IBluetoothService bluetoothService, ISchedulerProvider schedulerProvider)
{
_deviceInfo = deviceInfo;
_bluetoothService = bluetoothService;
_schedulerProvider = schedulerProvider;
_pairDeviceCommand = new DelegateCommand(PairDevice, () => !Status.IsProcessing && !IsAuthenticated);
_removeDeviceCommand = new DelegateCommand(RemoveDevice, () => !Status.IsProcessing && _deviceInfo.IsAuthenticated);
}
public PuzzleBoardViewModel(IPuzzlesService puzzlesService, ISchedulerProvider scheduler, IUserService userService)
{
_cells = new ObservableCollection<CellEmptyViewModel>();
_words = new ObservableCollection<WordViewModel>();
_scheduler = scheduler;
_userService = userService;
_puzzlesService = puzzlesService;
CreateCellsForBoard();
}
public TailViewStateController([NotNull] TailViewModel tailView, IStateBucketService stateBucketService, ISchedulerProvider schedulerProvider, ITailViewStateRestorer tailViewStateRestorer, ILogger logger, bool loadDefaults)
{
if (tailView == null) throw new ArgumentNullException(nameof(tailView));
_tailView = tailView;
var converter = new TailViewToStateConverter();
bool loadingSettings=false;
const string type = "TailView";
logger.Info("Loading state for {0}", tailView.Name);
//Load state
if (loadDefaults)
{
stateBucketService
.Lookup(type, tailView.Name)
.IfHasValue(tailviewstate =>
{
schedulerProvider.Background.Schedule(() =>
{
try
{
loadingSettings = true;
tailViewStateRestorer.Restore(tailView, tailviewstate);
}
finally
{
loadingSettings = false;
}
});
});
}
//write latest to file when something triggers a change
var selectedChanged = tailView.SearchCollection
.WhenValueChanged(sc=>sc.Selected,false)
.Where(vm => vm !=null)
.Select(vm=>vm.Text);
var metaChanged = _tailView.SearchMetadataCollection.Metadata.Connect()
.ToCollection()
.Select(metaData => metaData.ToArray());
var writer = selectedChanged.CombineLatest(metaChanged,(selected, metadata)=>new { selected , metadata })
.Where(_=> !loadingSettings)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(x => converter.Convert(_tailView.Name, x.selected, x.metadata))
.Subscribe(state =>
{
stateBucketService.Write(type, tailView.Name, state);
});
_cleanUp = new CompositeDisposable(writer);
}
public FileTailerViewModel(ILogger logger,ISchedulerProvider schedulerProvider, FileInfo fileInfo)
{
if (logger == null) throw new ArgumentNullException(nameof(logger));
if (schedulerProvider == null) throw new ArgumentNullException(nameof(schedulerProvider));
if (fileInfo == null) throw new ArgumentNullException(nameof(fileInfo));
var filterRequest = this.WhenValueChanged(vm => vm.SearchText).Throttle(TimeSpan.FromMilliseconds(125));
var autoChanged = this.WhenValueChanged(vm => vm.AutoTail);
var scroller = _userScrollRequested
.CombineLatest(autoChanged, (user, auto) =>
{
var mode = AutoTail ? ScrollingMode.Tail : ScrollingMode.User;
return new ScrollRequest(mode, user.PageSize, user.FirstIndex);
})
.Sample(TimeSpan.FromMilliseconds(150))
.DistinctUntilChanged();
var tailer = new FileTailer(fileInfo, filterRequest, scroller);
//create user display for count line count
var lineCounter = tailer.TotalLines.CombineLatest(tailer.MatchedLines,(total,matched)=>
{
return total == matched
? $"File has {total.ToString("#,###")} lines"
: $"Showing {matched.ToString("#,###")} of {total.ToString("#,###")} lines";
})
.Subscribe(text => LineCountText=text);
//load lines into observable collection
var loader = tailer.Lines.Connect()
.Transform(line => new LineProxy(line))
.Sort(SortExpressionComparer<LineProxy>.Ascending(proxy => proxy.Number))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _data)
.Subscribe(changes => logger.Info($"Rows changed {changes.Adds} adds, {changes.Removes} removed"),
ex => logger.Error(ex, "There is a problem with bind data"));
//monitor matching lines and start index,
var matchedLinesMonitor = tailer.MatchedLines
.Subscribe(matched => MatchedLineCount = matched);
//track first visible index
var firstIndexMonitor = tailer.Lines.Connect()
.QueryWhenChanged(lines =>lines.Count == 0 ? 0 : lines.Select(l => l.Index).Min())
.Subscribe(first=> FirstIndex= first);
_cleanUp = new CompositeDisposable(tailer,
lineCounter,
loader,
firstIndexMonitor,
matchedLinesMonitor,
Disposable.Create(() =>
{
_userScrollRequested.OnCompleted();
}));
}
public RealTimeModel(ISchedulerProvider schProvider, IBikeService bikeService)
{
_schProvider = schProvider;
_bikeService = bikeService;
_bikeDataSource = new SourceCache<StationDto, string>(bike => bike.Name);
_all = _bikeDataSource.AsObservableCache();
var data = GenerateRealTimeData();
_cleanup = new CompositeDisposable(_all, _bikeDataSource, data);
}
public DashboardModule(ITypeRegistry typeRegistry, IRegionManager regionManager, ISchedulerProvider schedulerProvider,
Func<IProfileActivatorAggregator> profileActivatorAggregatorFactory,
Func<IProfileDashboardView> profileDashboardViewFactory)
{
_typeRegistry = typeRegistry;
_regionManager = regionManager;
_schedulerProvider = schedulerProvider;
_profileActivatorAggregatorFactory = profileActivatorAggregatorFactory;
_profileDashboardViewFactory = profileDashboardViewFactory;
}
public NearToMarketViewer(INearToMarketService nearToMarketService, ISchedulerProvider schedulerProvider)
{
_cleanUp = nearToMarketService.Query(() => NearToMarketPercent)
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer<TradeProxy>.Descending(t => t.Timestamp))
.ObserveOn(schedulerProvider.MainThread)
.Bind(_data)
.DisposeMany()
.Subscribe();
}
public CrystalQuartzPanelApplication(
ISchedulerProvider schedulerProvider,
ISchedulerDataProvider schedulerDataProvider,
string customCssUrl) :
base(Assembly.GetAssembly(typeof(CrystalQuartzPanelApplication)), "CrystalQuartz.Web.Content.")
{
_schedulerProvider = schedulerProvider;
_schedulerDataProvider = schedulerDataProvider;
_customCssUrl = customCssUrl;
}
public PositionsViewer(ITradeService tradeService, ISchedulerProvider schedulerProvider)
{
_cleanUp = tradeService.Live.Connect()
.Group(trade => trade.CurrencyPair)
.Transform(group => new CurrencyPairPosition(group))
.Sort(SortExpressionComparer<CurrencyPairPosition>.Ascending(t => t.CurrencyPair))
.ObserveOn(schedulerProvider.MainThread)
.Bind(_data)
.DisposeMany()
.Subscribe();
}
public LayoutConverter([NotNull] IWindowFactory windowFactory,
[NotNull] IViewFactoryProvider viewFactoryProvider,
[NotNull] ISchedulerProvider schedulerProvider)
{
if (windowFactory == null) throw new ArgumentNullException(nameof(windowFactory));
if (viewFactoryProvider == null) throw new ArgumentNullException(nameof(viewFactoryProvider));
if (schedulerProvider == null) throw new ArgumentNullException(nameof(schedulerProvider));
_windowFactory = windowFactory;
_viewFactoryProvider = viewFactoryProvider;
_schedulerProvider = schedulerProvider;
}
public CrystalQuartzPanelApplication(
ISchedulerProvider schedulerProvider,
ISchedulerDataProvider schedulerDataProvider,
CrystalQuartzOptions options)
: base(Assembly.GetAssembly(typeof(CrystalQuartzPanelApplication)),
"CrystalQuartz.Application.Content.")
{
_schedulerProvider = schedulerProvider;
_schedulerDataProvider = schedulerDataProvider;
_options = options;
}
public WindowViewModel(IObjectProvider objectProvider,
IWindowFactory windowFactory,
ILogger logger,
IWindowsController windowsController,
RecentFilesViewModel recentFilesViewModel,
GeneralOptionsViewModel generalOptionsViewModel,
ISchedulerProvider schedulerProvider)
{
_logger = logger;
_windowsController = windowsController;
RecentFiles = recentFilesViewModel;
GeneralOptions = generalOptionsViewModel;
_schedulerProvider = schedulerProvider;
_objectProvider = objectProvider;
InterTabClient = new InterTabClient(windowFactory);
OpenFileCommand = new Command(OpenFile);
ShowInGitHubCommand = new Command(()=> Process.Start("https://github.com/RolandPheasant"));
ZoomOutCommand= new Command(()=> { GeneralOptions.Scale = GeneralOptions.Scale + 5; });
ZoomInCommand = new Command(() => { GeneralOptions.Scale = GeneralOptions.Scale - 5; });
SaveLayoutCommand = new Command(WalkTheLayout);
ExitCommmand = new Command(() => Application.Current.Shutdown());
Version = $"v{Assembly.GetEntryAssembly().GetName().Version.ToString(3)}";
var fileDropped = DropMonitor.Dropped.Subscribe(OpenFile);
var isEmptyChecker = Views.ToObservableChangeSet()
.ToCollection()
.Select(items=>items.Count)
.StartWith(0)
.Select(count=>count==0)
.Subscribe(isEmpty=> IsEmpty = isEmpty);
var openRecent = recentFilesViewModel.OpenFileRequest
.Subscribe(file =>
{
MenuIsOpen = false;
OpenFile(file);
});
_cleanUp = new CompositeDisposable(recentFilesViewModel,
isEmptyChecker,
fileDropped,
DropMonitor,
openRecent,
Disposable.Create(() =>
{
Views.Select(vc => vc.Content)
.OfType<IDisposable>()
.ForEach(d=>d.Dispose());
}));
}
public SearchHints(IRecentSearchCollection recentSearchCollection, ISchedulerProvider schedulerProvider)
{
//User feedback to guide them whilst typing
var searchText = this.WhenValueChanged(vm => vm.SearchText);
var useRegEx = this.WhenValueChanged(vm => vm.UseRegex);
//if regex then validate
var combined = searchText.CombineLatest(useRegEx, (text, regex) => new SearchRequest(text, regex))
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(searchRequest => searchRequest.BuildMessage())
.Publish();
IsValid = combined.Select(shm => shm.IsValid).DistinctUntilChanged().ForBinding();
Message = combined.Select(shm => shm.Message).DistinctUntilChanged().ForBinding();
var forceRefreshOfError = combined.Select(shm => shm.IsValid)
.DistinctUntilChanged()
.Subscribe(_ =>
{
this.OnPropertyChanged("SearchText");
});
var predictRegex = this.WhenValueChanged(vm => vm.SearchText)
.Select(text => _regexInspector.DoesThisLookLikeRegEx(text))
.Subscribe(likeRegex => UseRegex = likeRegex);
//Handle adding new search
var searchRequested = new Subject<SearchRequest>();
SearchRequested = searchRequested.AsObservable();
AddSearchCommand = new Command(async () =>
{
await Task.Run(() =>
{
recentSearchCollection.Add(new RecentSearch(SearchText));
searchRequested.OnNext(new SearchRequest(SearchText, UseRegex));
SearchText = string.Empty;
UseRegex = false;
});
}, () => IsValid.Value && SearchText.Length > 0);
var dataLoader = recentSearchCollection.Items.Connect()
// .Filter(filter)
.Transform(recentSearch => recentSearch.Text)
.Sort(SortExpressionComparer<string>.Ascending(str => str))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _hints)
.Subscribe();
_cleanUp = new CompositeDisposable(IsValid, Message, predictRegex, dataLoader, searchRequested.SetAsComplete(), combined.Connect(), forceRefreshOfError);
}
public GeneralOptionBindings([NotNull] ISetting<GeneralOptions> generalOptions, ISchedulerProvider schedulerProvider)
{
UsingDarkTheme = generalOptions.Value
.ObserveOn(schedulerProvider.MainThread)
.Select(options => options.Theme == Theme.Dark)
.ForBinding();
HighlightTail = generalOptions.Value
.ObserveOn(schedulerProvider.MainThread)
.Select(options => options.HighlightTail)
.ForBinding();
_cleanUp = new CompositeDisposable(UsingDarkTheme, HighlightTail);
}
public ThemeSetterJob(ISetting<GeneralOptions> setting, ISchedulerProvider schedulerProvider)
{
_cleanUp = setting.Value.Select(options => options.Theme)
.ObserveOn(schedulerProvider.MainThread)
.Subscribe(theme =>
{
var dark = theme == Theme.Dark;
var paletteHelper = new PaletteHelper();
paletteHelper.SetLightDark(dark);
paletteHelper.ReplaceAccentColor(theme.GetAccentColor());
});
}
public SelectionMonitor(ILogger logger, ISchedulerProvider schedulerProvider)
{
_logger = logger;
_schedulerProvider = schedulerProvider;
Selected = _selected.AsObservableList();
_cleanUp = new CompositeDisposable(
_selected,
_recentlyRemovedFromVisibleRange,
_controlSubscriber,
Selected,
//keep recent items only up to a certain number
_recentlyRemovedFromVisibleRange.LimitSizeTo(100).Subscribe());
}
public TradeGeneratorJob(IMessagePublisher<Trade> publisher,
ITradeGenerator tradeGenerator,
Lazy<ITradesCache> tradeService,
ISchedulerProvider schedulerProvider,
ILogger logger)
{
_publisher = publisher;
_tradeGenerator = tradeGenerator;
_tradeService = tradeService;
_schedulerProvider = schedulerProvider;
_logger = logger;
_runner = GenerateTradesAndMaintainCache();
}
public GeneralOptionsViewModel(ISetting <GeneralOptions> setting,
IRatingService ratingService,
ISchedulerProvider schedulerProvider)
{
var reader = setting.Value.Subscribe(options =>
{
UseDarkTheme = options.Theme == Theme.Dark;
HighlightTail = options.HighlightTail;
HighlightDuration = options.HighlightDuration;
Scale = options.Scale;
Rating = options.Rating;
OpenRecentOnStartup = options.OpenRecentOnStartup;
});
RequiresRestart = setting.Value.Select(options => options.Rating)
.HasChanged()
.ForBinding();
RestartCommand = new Command(() =>
{
Process.Start(Application.ResourceAssembly.Location);
Application.Current.Shutdown();
});
var writter = this.WhenAnyPropertyChanged()
.Subscribe(vm =>
{
setting.Write(new GeneralOptions(UseDarkTheme ? Theme.Dark : Theme.Light, HighlightTail, HighlightDuration, Scale, Rating, OpenRecentOnStartup));
});
HighlightDurationText = this.WhenValueChanged(vm => vm.HighlightDuration)
.DistinctUntilChanged()
.Select(value => value.ToString("0.00 Seconds"))
.ForBinding();
ScaleText = this.WhenValueChanged(vm => vm.Scale)
.DistinctUntilChanged()
.Select(value => $"{value} %")
.ForBinding();
ScaleRatio = this.WhenValueChanged(vm => vm.Scale)
.DistinctUntilChanged()
.Select(value => (decimal)value / (decimal)100)
.ForBinding();
_cleanUp = new CompositeDisposable(reader, writter, HighlightDurationText, ScaleText, ScaleRatio);
}
public RatingViewModel(
ITimeService timeService,
ITogglDataSource dataSource,
IRatingService ratingService,
IAnalyticsService analyticsService,
IOnboardingStorage onboardingStorage,
IMvxNavigationService navigationService,
ISchedulerProvider schedulerProvider,
IRxActionFactory rxActionFactory)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(ratingService, nameof(ratingService));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(navigationService, nameof(navigationService));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
this.dataSource = dataSource;
this.timeService = timeService;
this.ratingService = ratingService;
this.analyticsService = analyticsService;
this.onboardingStorage = onboardingStorage;
this.navigationService = navigationService;
this.schedulerProvider = schedulerProvider;
this.rxActionFactory = rxActionFactory;
Impression = impressionSubject.AsDriver(this.schedulerProvider);
CallToActionTitle = impressionSubject
.Select(callToActionTitle)
.AsDriver(this.schedulerProvider);
CallToActionDescription = impressionSubject
.Select(callToActionDescription)
.AsDriver(this.schedulerProvider);
CallToActionButtonTitle = impressionSubject
.Select(callToActionButtonTitle)
.AsDriver(this.schedulerProvider);
IsFeedbackSuccessViewShowing = isFeedbackSuccessViewShowing.AsDriver(this.schedulerProvider);
PerformMainAction = rxActionFactory.FromAsync(performMainAction);
}
public SearchCollection(ISearchInfoCollection searchInfoCollection, ISchedulerProvider schedulerProvider)
{
var viewModels = searchInfoCollection.Searches.Connect()
.Transform(tail => new SearchViewModel(tail, vm =>
{
searchInfoCollection.Remove(vm.Text);
}))
.DisposeMany()
.AsObservableCache();
var shared = viewModels.Connect();//.Publish();
var binderLoader = shared
.Sort(SortExpressionComparer <SearchViewModel>
.Ascending(tvm => tvm.SearchType == SearchType.All ? 1:2)
.ThenByAscending(tvm => tvm.Text))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _items)
.Subscribe();
var autoSelector = shared.WhereReasonsAre(ChangeReason.Add)
.Flatten()
.Select(change => change.Current)
.Subscribe(latest => Selected = latest);
var removed = shared.WhereReasonsAre(ChangeReason.Remove)
.Subscribe(_ => Selected = viewModels.Items.First());
var counter = shared.ToCollection()
.Subscribe(count => Count = count.Count);
SelectedText = this.WhenValueChanged(sc => sc.Selected)
.Where(x => x != null)
.Select(svm => svm.Text)
.Replay(1).RefCount();
Latest = this.WhenValueChanged(sc => sc.Selected)
.Where(x => x != null)
.Select(svm => svm.Latest)
.Switch()
.Replay(1).RefCount();
_cleanUp = new CompositeDisposable(viewModels, binderLoader, counter, removed, autoSelector);
}
public PropertyFilter(IObservableList <Animal> source, ISchedulerProvider schedulerProvider)
{
/*
* Create list which automatically filters:
*
* a) When the underlying list changes
* b) When IncludeInResults property changes
* c) NB: Add throttle when IncludeInResults properties can change in multiple animals in quick sucession
* (i.e. each time the prop changes the filter is re-assessed potentially leading to a flurry of updates - better to slow that down)
*/
Filtered = source.Connect()
.FilterOnProperty(animal => animal.IncludeInResults, animal => animal.IncludeInResults, TimeSpan.FromMilliseconds(250), schedulerProvider.Background)
.AsObservableList();
_cleanUp = Filtered;
}
public ToolbarController(IRegionManager regionManager,
ISchedulerProvider schedulerProvider,
IPersonalizationSettings settings,
ISettingsView settingsView,
IConnectivitySettingsView connectivitySettingsView,
IAccountSettingsView accountSettingsView,
IDemoView demoView)
{
_regionManager = regionManager;
_schedulerProvider = schedulerProvider;
_settings = settings;
_settingsView = settingsView;
_connectivitySettingsView = connectivitySettingsView;
_accountSettingsView = accountSettingsView;
_demoView = demoView;
_taskTaskbarIcon = new TaskbarIcon();
}
public TradesByTime([NotNull] IGroup <Trade, long, TimePeriod> @group,
ISchedulerProvider schedulerProvider)
{
if (@group == null)
{
throw new ArgumentNullException(nameof(@group));
}
Period = @group.Key;
_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 SearchHints(IRecentSearchCollection recentSearchCollection, ISchedulerProvider schedulerProvider)
{
//build a predicate when SearchText changes
//var filter = this.WhenValueChanged(t => t.SearchText)
// .Throttle(TimeSpan.FromMilliseconds(250))
// .Select(BuildFilter);
//User feedback to guide them whilst typing
var searchText = this.WhenValueChanged(vm => vm.SearchText);
var useRegEx = this.WhenValueChanged(vm => vm.UseRegex);
//if regex then validate
var combined = searchText.CombineLatest(useRegEx, (text, regex) => new SearchRequest(text, regex))
.Publish();
IsValid = combined.Select(searchRequest => searchRequest.BuildMessage()).ForBinding();
var predictRegex = this.WhenValueChanged(vm => vm.SearchText)
.Select(text => _regexInspector.DoesThisLookLikeRegEx(text))
.Subscribe(likeRegex => UseRegex = likeRegex);
//Handle adding new search
var searchRequested = new Subject <SearchRequest>();
SearchRequested = searchRequested.AsObservable();
AddSearchCommand = new Command(() =>
{
recentSearchCollection.Add(new RecentSearch(SearchText));
searchRequested.OnNext(new SearchRequest(SearchText, UseRegex));
SearchText = string.Empty;
UseRegex = false;
}, () => IsValid.Value.IsValid && SearchText.Length > 0);
//var dataLoader = recentSearchCollection.Items.Connect()
// .Filter(filter)
// .Transform(recentSearch=> recentSearch.Text)
// .Sort(SortExpressionComparer<string>.Ascending(str => str))
// .ObserveOn(schedulerProvider.MainThread)
// .Bind(out _hints)
// .Subscribe();
_cleanUp = new CompositeDisposable(IsValid, predictRegex, searchRequested.SetAsComplete(), combined.Connect());
}
public ApplicationViewModel(ILogger logger,
ISchedulerProvider schedulerProvider,
IImageManagementService imageManagementService,
Func <IImageViewModel> imageViewModelFactory,
Func <IImageFolderViewModel> imageFolderViewModelFactory)
{
_logger = logger;
_schedulerProvider = schedulerProvider;
_imageManagementService = imageManagementService;
_imageViewModelFactory = imageViewModelFactory;
_imageFolderViewModelFactory = imageFolderViewModelFactory;
Images = new ObservableCollection <IImageViewModel>();
ImageFolders = new ObservableCollection <IImageFolderViewModel>();
AddFolder = ReactiveCommand.CreateFromObservable <string, Unit>(ExecuteAddFolder);
}
protected BaseLocationEditorViewModel(
ISchedulerProvider schedulerProvider,
IPlacesProvider placesProvider,
IGeocodingProvider geocodingProvider,
INavigationService navigationService)
{
_geocodingProvider = geocodingProvider;
_navigationService = navigationService;
this.Changed(() => SearchText)
.Where(text => !string.IsNullOrEmpty(text))
.Throttle(TimeSpan.FromMilliseconds(300), schedulerProvider.DefaultScheduler)
.ObserveOn(schedulerProvider.SynchronizationContextScheduler)
.Subscribe(async searchText =>
{
IsSearching = true;
SearchResults = await placesProvider.GetAutoCompleteResponse(searchText);
IsSearching = false;
});
this.Changed(() => SearchText)
.Where(string.IsNullOrEmpty)
.Subscribe(_ => SearchResults = GetEmptyAutocompleteResult());
this.Changed(() => SelectedSearchResult)
.Where(result => result is EmptyAutocompleteResultModel)
.Cast <EmptyAutocompleteResultModel>()
.ObserveOn(schedulerProvider.SynchronizationContextScheduler)
.Subscribe(selectedResult =>
{
if (selectedResult.Address == null)
{
NavigateToLocationEditorViewModel(selectedResult);
}
else
{
SelectedAddress = selectedResult.Address;
_navigationService.GoBack();
}
});
SelectedAutoCompleteResultModelObservable.Subscribe(async result =>
{
await SetAutoCompleteResultModel(result.PlaceId);
});
}
static PagesHandler()
{
var options = new CrystalQuartzOptions
{
CustomCssUrl = Configuration.ConfigUtils.CustomCssUrl
};
ISchedulerProvider schedulerProvider = Configuration.ConfigUtils.SchedulerProvider;
ISchedulerDataProvider schedulerDataProvider = new DefaultSchedulerDataProvider(schedulerProvider);
Application application = new CrystalQuartzPanelApplication(
schedulerProvider,
schedulerDataProvider,
options);
RunningApplication = application.Run();
}
public RunnableStateProvider(
ISchedulerProvider schedulerProvider,
ICheckoutInputProvider checkoutInputProvider,
IPrepareRunnableState prepareRunnableState)
{
_State = checkoutInputProvider.Input
.Throttle(TimeSpan.FromMilliseconds(150), schedulerProvider.MainThread)
.DistinctUntilChanged()
.ObserveOn(schedulerProvider.TaskPool)
.Select(prepareRunnableState.Prepare)
.Switch()
.ToGuiProperty(this, nameof(State), new ConfigurationState <RunnerRepoInfo>(
GetResponse <RunnerRepoInfo> .Fail("Constructing runnable state"))
{
IsHaltingError = false
}, deferSubscription: true);
}
public TradesByPercentViewer(INearToMarketService nearToMarketService, ISchedulerProvider schedulerProvider, ILogger logger)
{
var locker = new object();
var grouperRefresher = Observable.Interval(TimeSpan.FromSeconds(1))
.Synchronize(locker)
.Select(_ => Unit.Default);
_cleanUp = nearToMarketService.Query(() => 4)
.Synchronize(locker)
.Group(trade => (int)Math.Truncate(Math.Abs(trade.PercentFromMarket)), grouperRefresher)
.Transform(group => new Domain.Model.TradesByPercentDiff(group, schedulerProvider, logger))
.Sort(SortExpressionComparer <Domain.Model.TradesByPercentDiff> .Ascending(t => t.PercentBand), SortOptimisations.ComparesImmutableValuesOnly)
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _data)
.DisposeMany()
.Subscribe(_ => { }, ex => logger.Error(ex, ex.Message));
}
public TradeService(ILogger logger, TradeGenerator tradeGenerator, ISchedulerProvider schedulerProvider)
{
_logger = logger;
_tradeGenerator = tradeGenerator;
_schedulerProvider = schedulerProvider;
//construct a cache specifying that the unique key is Trade.Id
_tradesSource = new SourceCache <Trade, long>(trade => trade.Id);
//call AsObservableCache() to hide the update methods as we are exposing the cache
_tradesCache = _tradesSource.AsObservableCache();
//code to emulate an external trade provider
var tradeLoader = GenerateTradesAndMaintainCache();
_cleanup = new CompositeDisposable(_tradesCache, _tradesSource, tradeLoader);
}
public DestinationLocationEditorViewModel(
ISchedulerProvider schedulerProvider,
INavigationService navigationService,
IPlacesProvider placesProvider,
IGeocodingProvider geocodingProvider,
IChooseOnMapViewModelFactory chooseOnMapViewModelFactory,
IEmptyAutocompleteResultProvider autocompleteResultProvider) : base(schedulerProvider, placesProvider, geocodingProvider, navigationService)
{
_navigationService = navigationService;
_chooseOnMapViewModelFactory = chooseOnMapViewModelFactory;
_autocompleteResultProvider = autocompleteResultProvider;
this.Changed(() => SelectedSearchResult)
.Where(r => r is SetLocationOnMapResultModel)
.ObserveOn(schedulerProvider.SynchronizationContextScheduler)
.Subscribe(NavigateToChooseDestinationOnMapViewModel);
}
public static void UseCrystalQuartz(
this IAppBuilder app,
ISchedulerProvider scheduleProvider,
CrystalQuartzOptions options)
{
CrystalQuartzOptions actualOptions = options ?? new CrystalQuartzOptions();
string url = actualOptions.Path ?? "/quartz";
app.Map(url, privateApp =>
{
if (actualOptions.UseAuthentication)
{
privateApp.UseBasicAuthentication("SecureApi", async(u, p) => await Authenticate(actualOptions, u, p));
}
privateApp.Use(typeof(CrystalQuartzPanelMiddleware), scheduleProvider, actualOptions);
});
}
public LayoutService(ISettingsStore store,
ILogger logger,
ISchedulerProvider schedulerProvider,
IObjectProvider objectProvider,
IApplicationStateNotifier stateNotifier)
{
_store = store;
_logger = logger;
_objectProvider = objectProvider;
schedulerProvider.MainThread.Schedule(Restore);
stateNotifier.StateChanged.Where(state => state == ApplicationState.ShuttingDown)
.Subscribe(_ =>
{
Write();
});
}
public SelectTagsViewModel(
INavigationService navigationService,
IInteractorFactory interactorFactory,
ISchedulerProvider schedulerProvider,
IRxActionFactory rxActionFactory)
: base(navigationService)
{
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
this.interactorFactory = interactorFactory;
this.schedulerProvider = schedulerProvider;
Save = rxActionFactory.FromAction(save);
SelectTag = rxActionFactory.FromAsync <SelectableTagBaseViewModel>(selectTag);
}
public SearchHints(IRecentSearchCollection recentSearchCollection, ISchedulerProvider schedulerProvider)
{
//build a predicate when SearchText changes
var filter = this.WhenValueChanged(t => t.SearchText)
.Throttle(TimeSpan.FromMilliseconds(250))
.Select(BuildFilter);
//observe customers and currency pairs using OR operator, and bind to the observable collection
_cleanUp = recentSearchCollection.Items.Connect()
.Filter(filter) //filter strings
.Transform(recentSearch => recentSearch.Text)
.Sort(SortExpressionComparer <string> .Ascending(str => str))
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _hints) //bind to hints list
.Subscribe();
}
public SelectClientViewModel(
IInteractorFactory interactorFactory,
IMvxNavigationService navigationService,
ISchedulerProvider schedulerProvider,
IRxActionFactory rxActionFactory)
{
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(navigationService, nameof(navigationService));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
this.interactorFactory = interactorFactory;
this.navigationService = navigationService;
this.rxActionFactory = rxActionFactory;
Close = rxActionFactory.FromAsync(close);
SelectClient = rxActionFactory.FromAsync<SelectableClientBaseViewModel>(selectClient);
}
public static void UseCrystalQuartz(
this IAppBuilder app,
ISchedulerProvider schedulerProvider,
CrystalQuartzOptions options)
{
CrystalQuartzOptions actualOptions = options ?? new CrystalQuartzOptions();
string url = actualOptions.Path ?? "/quartz";
app.Map(url, privateApp =>
{
privateApp.Use <CrystalQuartzPanelMiddleware>(schedulerProvider, new Options(
actualOptions.TimelineSpan,
SchedulerEngineProviders.SchedulerEngineResolvers,
actualOptions.LazyInit,
actualOptions.CustomCssUrl,
FrameworkVersion.Value));
});
}
public MainViewModel(
ISchedulerProvider schedulerProvider,
IGeocodingProvider geocodingProvider,
ILocationManager locationManager,
INavigationService navigationService,
ISearchPlaceViewModelFactory searchPlaceViewModelFactory)
{
_schedulerProvider = schedulerProvider;
_geocodingProvider = geocodingProvider;
_locationManager = locationManager;
MyLocationChanged = locationManager.LocationChanged;
PickupLocationEditorViewModel = searchPlaceViewModelFactory.GetPickupLocationEditorViewModel();
DestinationLocationEditorViewModel = searchPlaceViewModelFactory.GetDestinationLocationEditorViewModel();
_navigationService = navigationService;
}
public TradesByPercentDiff([NotNull] IGroup <Trade, long, int> group, [NotNull] ISchedulerProvider schedulerProvider, ILogger logger)
{
if (schedulerProvider == null)
{
throw new ArgumentNullException(nameof(schedulerProvider));
}
_group = @group ?? throw new ArgumentNullException(nameof(@group));
PercentBand = group.Key;
_cleanUp = group.Cache.Connect()
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer <TradeProxy> .Descending(p => p.Timestamp))
.ObserveOn(schedulerProvider.MainThread)
.Bind(Data)
.DisposeMany()
.Subscribe(_ => { }, ex => logger.Error(ex, "Error in TradesByPercentDiff"));
}
public MainPageViewModel(IWindowService windowService,
IDataTransferService dataTransferService,
IClipboardService clipboardService,
IHttpService httpService,
ISchedulerProvider schedulerProvider,
ITextToSpeechService textToSpeechService,
ApplicationSettingsService settingsService,
ISettingsService settingsUiService,
INavigationService navigationService)
{
Text = DefineClipboardObservable(windowService.IsVisibleObservable, clipboardService).ToReactiveProperty();
SelectAllTextTrigger = DefineSelectAllTextTriggerObservable(windowService.IsVisibleObservable, schedulerProvider.Default)
.ToReadonlyReactiveProperty(mode: ReactivePropertyMode.None);
var formattedStringObservable = DefineFormattedStringObservable(Text);
var validLinkObservable = DefineValidUriObservable(formattedStringObservable);
ShareCommand = validLinkObservable.ToReactiveCommand();
KeyPressedCommand = validLinkObservable.ToReactiveCommand <object>();
var enterPressedObservable = DefineEnterPressedObservable(KeyPressedCommand);
var shareTrigger = DefineShareTrigger(formattedStringObservable, ShareCommand, enterPressedObservable);
var urlTitleResolveObservable = DefineUrlTitleResolveObservable(shareTrigger, httpService);
IsInProgress = DefineInProgressObservable(shareTrigger, urlTitleResolveObservable)
.ToReadonlyReactiveProperty();
ErrorMessage = DefineErrorMessageObservable(shareTrigger, urlTitleResolveObservable)
.ToReadonlyReactiveProperty();
_textToSpeechSubscription = DefineTextToSpeachObservable(urlTitleResolveObservable, settingsService, textToSpeechService)
.Subscribe();
_shareLinkSubscription = urlTitleResolveObservable.ObserveOnUI()
.Subscribe(shareData => ShareLink(dataTransferService, shareData.Title, shareData.Uri));
SettingsCommand = new DelegateCommand(settingsUiService.ShowSettings);
HistoryCommand = new DelegateCommand(() => navigationService.Navigate("History", null));
}
/// <summary>
/// 静态构造
/// </summary>
static PagesHandler()
{
var options = new CrystalQuartzOptions
{
//css地址
CustomCssUrl = Configuration.ConfigUtils.CustomCssUrl
};
//调度器
ISchedulerProvider schedulerProvider = Configuration.ConfigUtils.SchedulerProvider;
//初始化 应用程序
Application application = new CrystalQuartzPanelApplication(
schedulerProvider,
options.ToRuntimeOptions(SchedulerEngineProviders.SchedulerEngineResolvers, FrameworkVersion.Value));
//运行
RunningApplication = application.Run();
}
public LiveTradesViewer(ITradeService tradeService, SearchHints searchHints, ISchedulerProvider schedulerProvider)
{
SearchHints = searchHints;
var filter = SearchHints.WhenValueChanged(t => t.SearchText)
.Select(BuildFilter);
var loader = tradeService.Live.Connect()
.BatchIf(this.WhenValueChanged(x => x.Paused), null, null) //I need to fix the API, so nulls do not have to be passed in
.Filter(filter) // apply user filter
.Transform(trade => new TradeProxy(trade))
.Sort(SortExpressionComparer <TradeProxy> .Descending(t => t.Timestamp), SortOptimisations.ComparesImmutableValuesOnly, 25)
.ObserveOn(schedulerProvider.MainThread)
.Bind(out _data) // update observable collection bindings
.DisposeMany() //since TradeProxy is disposable dispose when no longer required
.Subscribe();
_cleanUp = new CompositeDisposable(loader, searchHints);
}
public ForgotPasswordViewModel(
ITimeService timeService,
IUserAccessManager userAccessManager,
IAnalyticsService analyticsService,
ISchedulerProvider schedulerProvider,
INavigationService navigationService,
IRxActionFactory rxActionFactory)
: base(navigationService)
{
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(userAccessManager, nameof(userAccessManager));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
this.timeService = timeService;
this.userAccessManager = userAccessManager;
this.analyticsService = analyticsService;
this.rxActionFactory = rxActionFactory;
Reset = rxActionFactory.FromObservable(reset);
PasswordResetWithInvalidEmail = passwordResetWithInvalidEmailSubject.AsDriver(schedulerProvider);
var resetActionStartedObservable = Reset
.Executing
.Where(executing => executing)
.Select(_ => (Exception)null);
ErrorMessage = Reset.Errors
.Merge(resetActionStartedObservable)
.Select(toErrorString)
.StartWith("")
.DistinctUntilChanged();
PasswordResetSuccessful = Reset.Elements
.Select(_ => true)
.StartWith(false)
.AsDriver(schedulerProvider);
EmailValid = Email
.Select(email => email.IsValid)
.DistinctUntilChanged();
}
public TailViewModelFactory([NotNull] IObjectProvider objectProvider,
[NotNull] ISchedulerProvider schedulerProvider,
[NotNull] IColourProvider colourProvider,
[NotNull] ISearchMetadataFactory searchMetadataFactory,
[NotNull] IIconProvider iconProvider,
[NotNull] ITailViewStateControllerFactory tailViewStateControllerFactory,
[NotNull] ITextAssociationCollection textAssociationCollection,
[NotNull] IThemeProvider themeProvider)
{
if (objectProvider == null)
{
throw new ArgumentNullException(nameof(objectProvider));
}
if (schedulerProvider == null)
{
throw new ArgumentNullException(nameof(schedulerProvider));
}
if (colourProvider == null)
{
throw new ArgumentNullException(nameof(colourProvider));
}
if (searchMetadataFactory == null)
{
throw new ArgumentNullException(nameof(searchMetadataFactory));
}
if (iconProvider == null)
{
throw new ArgumentNullException(nameof(iconProvider));
}
if (tailViewStateControllerFactory == null)
{
throw new ArgumentNullException(nameof(tailViewStateControllerFactory));
}
_objectProvider = objectProvider;
_schedulerProvider = schedulerProvider;
_colourProvider = colourProvider;
_searchMetadataFactory = searchMetadataFactory;
_iconProvider = iconProvider;
_tailViewStateControllerFactory = tailViewStateControllerFactory;
_textAssociationCollection = textAssociationCollection;
_themeProvider = themeProvider;
}
public JourneyService
(
IParticipationService participationService,
IParticipantService participantService,
ILoggingProvider logger,
ICrmConsumerProvider crmProvider,
ISchedulerProvider scheduler,
//IConfigurationProvider configProvider,
IFailedTransactionService failedTransactionService
)
{
_participationService = participationService;
_participantService = participantService;
_logger = logger;
_crmProvider = crmProvider;
_scheduler = scheduler;
//_configProvider = configProvider;
_failedTransactionService = failedTransactionService;
}
public GeneralOptionsViewModel(ISetting <GeneralOptions> setting, ISchedulerProvider schedulerProvider)
{
var reader = setting.Value.Subscribe(options =>
{
UseDarkTheme = options.Theme == Theme.Dark;
HighlightTail = options.HighlightTail;
HighlightDuration = options.HighlightDuration;
Scale = options.Scale;
});
var writter = this.WhenAnyPropertyChanged()
.Subscribe(vm =>
{
setting.Write(new GeneralOptions(UseDarkTheme ? Theme.Dark : Theme.Light, HighlightTail, HighlightDuration, Scale));
});
var themeSetter = setting.Value.Select(options => options.Theme)
.ObserveOn(schedulerProvider.MainThread)
.Subscribe(theme =>
{
new PaletteHelper().SetLightDark(theme == Theme.Dark);
});
HighlightDurationText = this.WhenValueChanged(vm => vm.HighlightDuration)
.Select(value => value.ToString("0.00 Seconds"))
.ForBinding();
ScaleText = this.WhenValueChanged(vm => vm.Scale)
.Select(value => $"{value} %")
.ForBinding();
ScaleRatio = this.WhenValueChanged(vm => vm.Scale)
.Select(value => (decimal)value / (decimal)100)
//.Sample(Times)
.Do(x => { Console.WriteLine(); })
.ForBinding();
_cleanUp = new CompositeDisposable(reader, writter, themeSetter, HighlightDurationText, ScaleText, ScaleRatio);
}
public WorkLocationEditorViewModel(
ISchedulerProvider schedulerProvider,
INavigationService navigationService,
IPlacesProvider placesProvider,
IEmptyAutocompleteResultProvider autocompleteResultProvider,
ISettingsProvider settingsProvider,
IGeocodingProvider geocodingProvider) : base(schedulerProvider, placesProvider, geocodingProvider, navigationService)
{
_navigationService = navigationService;
_autocompleteResultProvider = autocompleteResultProvider;
_settingsProvider = settingsProvider;
_geocodingProvider = geocodingProvider;
this.Changed(() => SelectedSearchResult)
.Where(r => r is SetLocationOnMapResultModel)
.Subscribe(result =>
{
navigationService.NavigateTo <ChooseWorkAddressOnMapViewModel>();
});
}
