public GetPreferencesInteractor(ITogglDataSource dataSource)
{
this.dataSource = dataSource;
}
public CheckForInaccessibleWorkspacesState(ITogglDataSource dataSource)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
this.dataSource = dataSource;
}
private static void configurePullTransitions(
ITransitionConfigurator transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
ITimeService timeService,
IAnalyticsService analyticsService,
IScheduler scheduler,
StateResult entryPoint,
IObservable <Unit> delayCancellation)
{
var rnd = new Random();
var apiDelay = new RetryDelayService(rnd);
var statusDelay = new RetryDelayService(rnd);
var fetchAllSince = new FetchAllSinceState(database, api, timeService);
var persistWorkspaces =
new PersistListState <IWorkspace, IDatabaseWorkspace, IThreadSafeWorkspace>(dataSource.Workspaces, Workspace.Clean);
var updateWorkspacesSinceDate =
new SinceDateUpdatingState <IWorkspace, IDatabaseWorkspace>(database.SinceParameters);
var detectNoWorkspaceState = new NoWorkspaceDetectingState(dataSource);
var persistWorkspaceFeatures =
new PersistListState <IWorkspaceFeatureCollection, IDatabaseWorkspaceFeatureCollection, IThreadSafeWorkspaceFeatureCollection>(
dataSource.WorkspaceFeatures, WorkspaceFeatureCollection.From);
var persistUser =
new PersistSingletonState <IUser, IDatabaseUser, IThreadSafeUser>(dataSource.User, User.Clean);
var noDefaultWorkspaceTrackingState = new NoDefaultWorkspaceTrackingState(analyticsService);
var persistTags =
new PersistListState <ITag, IDatabaseTag, IThreadSafeTag>(dataSource.Tags, Tag.Clean);
var updateTagsSinceDate = new SinceDateUpdatingState <ITag, IDatabaseTag>(database.SinceParameters);
var persistClients =
new PersistListState <IClient, IDatabaseClient, IThreadSafeClient>(dataSource.Clients, Client.Clean);
var updateClientsSinceDate = new SinceDateUpdatingState <IClient, IDatabaseClient>(database.SinceParameters);
var persistPreferences =
new PersistSingletonState <IPreferences, IDatabasePreferences, IThreadSafePreferences>(dataSource.Preferences, Preferences.Clean);
var persistProjects =
new PersistListState <IProject, IDatabaseProject, IThreadSafeProject>(dataSource.Projects, Project.Clean);
var updateProjectsSinceDate = new SinceDateUpdatingState <IProject, IDatabaseProject>(database.SinceParameters);
var createGhostProjects = new CreateGhostProjectsState(dataSource.Projects, analyticsService);
var persistTimeEntries =
new PersistListState <ITimeEntry, IDatabaseTimeEntry, IThreadSafeTimeEntry>(dataSource.TimeEntries, TimeEntry.Clean);
var updateTimeEntriesSinceDate = new SinceDateUpdatingState <ITimeEntry, IDatabaseTimeEntry>(database.SinceParameters);
var persistTasks =
new PersistListState <ITask, IDatabaseTask, IThreadSafeTask>(dataSource.Tasks, Task.Clean);
var updateTasksSinceDate = new SinceDateUpdatingState <ITask, IDatabaseTask>(database.SinceParameters);
var refetchInaccessibleProjects =
new TryFetchInaccessibleProjectsState(dataSource.Projects, timeService, api.Projects);
var retryOrThrow = new SevereApiExceptionsRethrowingState();
var checkServerStatus = new CheckServerStatusState(api, scheduler, apiDelay, statusDelay, delayCancellation);
var finished = new ResetAPIDelayState(apiDelay);
var deleteOlderEntries = new DeleteOldEntriesState(timeService, dataSource.TimeEntries);
var deleteNonReferencedGhostProjects = new DeleteNonReferencedProjectGhostsState(dataSource.Projects, dataSource.TimeEntries);
transitions.ConfigureTransition(entryPoint, fetchAllSince);
transitions.ConfigureTransition(fetchAllSince.FetchStarted, persistWorkspaces);
transitions.ConfigureTransition(persistWorkspaces.FinishedPersisting, updateWorkspacesSinceDate);
transitions.ConfigureTransition(updateWorkspacesSinceDate.Finished, detectNoWorkspaceState);
transitions.ConfigureTransition(detectNoWorkspaceState.Continue, persistUser);
transitions.ConfigureTransition(persistUser.FinishedPersisting, noDefaultWorkspaceTrackingState);
transitions.ConfigureTransition(noDefaultWorkspaceTrackingState.Continue, persistWorkspaceFeatures);
transitions.ConfigureTransition(persistWorkspaceFeatures.FinishedPersisting, persistPreferences);
transitions.ConfigureTransition(persistPreferences.FinishedPersisting, persistTags);
transitions.ConfigureTransition(persistTags.FinishedPersisting, updateTagsSinceDate);
transitions.ConfigureTransition(updateTagsSinceDate.Finished, persistClients);
transitions.ConfigureTransition(persistClients.FinishedPersisting, updateClientsSinceDate);
transitions.ConfigureTransition(updateClientsSinceDate.Finished, persistProjects);
transitions.ConfigureTransition(persistProjects.FinishedPersisting, updateProjectsSinceDate);
transitions.ConfigureTransition(updateProjectsSinceDate.Finished, persistTasks);
transitions.ConfigureTransition(persistTasks.FinishedPersisting, updateTasksSinceDate);
transitions.ConfigureTransition(updateTasksSinceDate.Finished, createGhostProjects);
transitions.ConfigureTransition(createGhostProjects.FinishedPersisting, persistTimeEntries);
transitions.ConfigureTransition(persistTimeEntries.FinishedPersisting, updateTimeEntriesSinceDate);
transitions.ConfigureTransition(updateTimeEntriesSinceDate.Finished, refetchInaccessibleProjects);
transitions.ConfigureTransition(refetchInaccessibleProjects.FetchNext, refetchInaccessibleProjects);
transitions.ConfigureTransition(refetchInaccessibleProjects.FinishedPersisting, deleteOlderEntries);
transitions.ConfigureTransition(deleteOlderEntries.FinishedDeleting, deleteNonReferencedGhostProjects);
transitions.ConfigureTransition(persistWorkspaces.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(persistUser.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(persistWorkspaceFeatures.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(persistPreferences.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(persistTags.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(persistClients.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(persistProjects.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(persistTasks.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(createGhostProjects.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(persistTimeEntries.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(refetchInaccessibleProjects.ErrorOccured, retryOrThrow);
transitions.ConfigureTransition(retryOrThrow.Retry, checkServerStatus);
transitions.ConfigureTransition(checkServerStatus.Retry, checkServerStatus);
transitions.ConfigureTransition(checkServerStatus.ServerIsAvailable, finished);
transitions.ConfigureTransition(finished.Continue, fetchAllSince);
}
public EditDurationViewModel(INavigationService navigationService, ITimeService timeService, ITogglDataSource dataSource, IAnalyticsService analyticsService, IRxActionFactory rxActionFactory, ISchedulerProvider schedulerProvider)
{
Ensure.Argument.IsNotNull(navigationService, nameof(navigationService));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
this.timeService = timeService;
this.navigationService = navigationService;
this.analyticsService = analyticsService;
Save = rxActionFactory.FromAsync(save);
Close = rxActionFactory.FromAsync(close);
EditStartTime = rxActionFactory.FromAction(editStartTime);
EditStopTime = rxActionFactory.FromAction(editStopTime);
StopEditingTime = rxActionFactory.FromAction(stopEditingTime);
ChangeStartTime = rxActionFactory.FromAction <DateTimeOffset>(updateStartTime);
ChangeStopTime = rxActionFactory.FromAction <DateTimeOffset>(updateStopTime);
ChangeActiveTime = rxActionFactory.FromAction <DateTimeOffset>(changeActiveTime);
ChangeDuration = rxActionFactory.FromAction <TimeSpan>(changeDuration);
StopTimeEntry = rxActionFactory.FromAction(stopTimeEntry);
var start = startTime.Where(v => v != default(DateTimeOffset));
var stop = stopTime.Where(v => v != default(DateTimeOffset));
var duration = Observable.CombineLatest(start, stop, (startValue, stopValue) => stopValue - startValue);
StartTime = start.AsDriver(schedulerProvider);
StopTime = stop.AsDriver(schedulerProvider);
Duration = duration.AsDriver(schedulerProvider);
IsEditingTime = editMode.Select(v => v != EditMode.None).AsDriver(schedulerProvider);
IsEditingStartTime = editMode.Select(v => v == EditMode.StartTime).AsDriver(schedulerProvider);
IsEditingStopTime = editMode.Select(v => v == EditMode.EndTime).AsDriver(schedulerProvider);
var preferences = dataSource.Preferences.Current.ShareReplay();
var dateFormat = preferences.Select(p => p.DateFormat);
var timeFormat = preferences.Select(p => p.TimeOfDayFormat);
var durationFormat = preferences.Select(p => p.DurationFormat);
StartDateString = Observable.CombineLatest(start, dateFormat, toFormattedString)
.AsDriver(schedulerProvider);
StartTimeString = Observable.CombineLatest(start, timeFormat, toFormattedString)
.AsDriver(schedulerProvider);
StopDateString = Observable.CombineLatest(stop, dateFormat, toFormattedString)
.AsDriver(schedulerProvider);
StopTimeString = Observable.CombineLatest(stop, timeFormat, toFormattedString)
.AsDriver(schedulerProvider);
DurationString = Observable.CombineLatest(duration, durationFormat, toFormattedString)
.AsDriver(schedulerProvider);
TimeFormat = timeFormat.AsDriver(schedulerProvider);
IsRunning = isRunning.AsDriver(schedulerProvider);
MinimumDateTime = minimumDateTime.AsDriver(schedulerProvider);
MaximumDateTime = maximumDateTime.AsDriver(schedulerProvider);
MinimumStartTime = stopTime.Select(v => v.AddHours(-MaxTimeEntryDurationInHours)).AsDriver(schedulerProvider);
MaximumStartTime = stopTime.AsDriver(schedulerProvider);
MinimumStopTime = startTime.AsDriver(schedulerProvider);
MaximumStopTime = startTime.Select(v => v.AddHours(MaxTimeEntryDurationInHours)).AsDriver(schedulerProvider);
}
public GetItemsThatFailedToSyncInteractor(ITogglDataSource dataSource)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
this.dataSource = dataSource;
}
private void onDataSource(ITogglDataSource dataSource)
{
Mvx.RegisterSingleton(dataSource);
navigationService.Navigate <MainViewModel>();
}
public EditTimeEntryViewModel(
ITimeService timeService,
ITogglDataSource dataSource,
ISyncManager syncManager,
IInteractorFactory interactorFactory,
INavigationService navigationService,
IOnboardingStorage onboardingStorage,
IDialogService dialogService,
IAnalyticsService analyticsService,
IStopwatchProvider stopwatchProvider,
IRxActionFactory actionFactory,
ISchedulerProvider schedulerProvider)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(syncManager, nameof(syncManager));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(dialogService, nameof(dialogService));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(navigationService, nameof(navigationService));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(stopwatchProvider, nameof(stopwatchProvider));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(actionFactory, nameof(actionFactory));
this.dataSource = dataSource;
this.syncManager = syncManager;
this.timeService = timeService;
this.dialogService = dialogService;
this.interactorFactory = interactorFactory;
this.navigationService = navigationService;
this.analyticsService = analyticsService;
this.stopwatchProvider = stopwatchProvider;
this.schedulerProvider = schedulerProvider;
this.actionFactory = actionFactory;
OnboardingStorage = onboardingStorage;
workspaceIdSubject
.Where(id => id.HasValue)
.Subscribe(id => workspaceId = id.Value)
.DisposedBy(disposeBag);
isEditingDescriptionSubject = new BehaviorSubject <bool>(false);
Description = new BehaviorRelay <string>(string.Empty, CommonFunctions.Trim);
projectClientTaskSubject = new BehaviorSubject <ProjectClientTaskInfo>(ProjectClientTaskInfo.Empty);
ProjectClientTask = projectClientTaskSubject
.AsDriver(ProjectClientTaskInfo.Empty, schedulerProvider);
IsBillableAvailable = workspaceIdSubject
.Where(id => id.HasValue)
.SelectMany(workspaceId => interactorFactory.IsBillableAvailableForWorkspace(workspaceId.Value).Execute())
.DistinctUntilChanged()
.AsDriver(false, schedulerProvider);
isBillableSubject = new BehaviorSubject <bool>(false);
IsBillable = isBillableSubject
.DistinctUntilChanged()
.AsDriver(false, schedulerProvider);
startTimeSubject = new BehaviorSubject <DateTimeOffset>(DateTimeOffset.UtcNow);
var startTimeObservable = startTimeSubject.DistinctUntilChanged();
StartTime = startTimeObservable
.AsDriver(default(DateTimeOffset), schedulerProvider);
var now = timeService.CurrentDateTimeObservable.StartWith(timeService.CurrentDateTime);
durationSubject = new ReplaySubject <TimeSpan?>(bufferSize: 1);
Duration =
durationSubject
.Select(duration
=> duration.HasValue
? Observable.Return(duration.Value)
: now.CombineLatest(
startTimeObservable,
(currentTime, startTime) => currentTime - startTime))
.Switch()
.DistinctUntilChanged()
.AsDriver(TimeSpan.Zero, schedulerProvider);
var stopTimeObservable = Observable.CombineLatest(startTimeObservable, durationSubject, calculateStopTime)
.DistinctUntilChanged();
StopTime = stopTimeObservable
.AsDriver(null, schedulerProvider);
var isTimeEntryRunningObservable = stopTimeObservable
.Select(stopTime => !stopTime.HasValue)
.Do(value => isRunning = value)
.DistinctUntilChanged();
IsTimeEntryRunning = isTimeEntryRunningObservable
.AsDriver(false, schedulerProvider);
tagsSubject = new BehaviorSubject <IEnumerable <IThreadSafeTag> >(Enumerable.Empty <IThreadSafeTag>());
Tags = tagsSubject
.Select(tags => tags.Select(ellipsize).ToImmutableList())
.AsDriver(ImmutableList <string> .Empty, schedulerProvider);
isInaccessibleSubject = new BehaviorSubject <bool>(false);
IsInaccessible = isInaccessibleSubject
.DistinctUntilChanged()
.AsDriver(false, schedulerProvider);
syncErrorMessageSubject = new BehaviorSubject <string>(string.Empty);
SyncErrorMessage = syncErrorMessageSubject
.Select(error => error ?? string.Empty)
.DistinctUntilChanged()
.AsDriver(string.Empty, schedulerProvider);
IsSyncErrorMessageVisible = syncErrorMessageSubject
.Select(error => !string.IsNullOrEmpty(error))
.DistinctUntilChanged()
.AsDriver(false, schedulerProvider);
Preferences = interactorFactory.GetPreferences().Execute()
.AsDriver(null, schedulerProvider);
// Actions
Close = actionFactory.FromAsync(closeWithConfirmation);
SelectProject = actionFactory.FromAsync(selectProject);
SelectTags = actionFactory.FromAsync(selectTags);
ToggleBillable = actionFactory.FromAction(toggleBillable);
EditTimes = actionFactory.FromAsync <EditViewTapSource>(editTimes);
SelectStartDate = actionFactory.FromAsync(selectStartDate);
StopTimeEntry = actionFactory.FromAction(stopTimeEntry, isTimeEntryRunningObservable);
DismissSyncErrorMessage = actionFactory.FromAction(dismissSyncErrorMessage);
Save = actionFactory.FromAsync(save);
Delete = actionFactory.FromAsync(delete);
}
public ReportsViewModel(ITogglDataSource dataSource,
ITimeService timeService,
INavigationService navigationService,
IInteractorFactory interactorFactory,
IAnalyticsService analyticsService,
ISchedulerProvider schedulerProvider,
IRxActionFactory rxActionFactory)
: base(navigationService)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(navigationService, nameof(navigationService));
this.dataSource = dataSource;
this.timeService = timeService;
this.analyticsService = analyticsService;
this.interactorFactory = interactorFactory;
CalendarViewModel = new ReportsCalendarViewModel(timeService, dataSource, rxActionFactory, navigationService, schedulerProvider);
var totalsObservable = reportSubject
.SelectMany(_ => interactorFactory.GetReportsTotals(userId, workspaceId, startDate, endDate).Execute())
.Catch <ITimeEntriesTotals, OfflineException>(_ => Observable.Return <ITimeEntriesTotals>(null))
.Where(report => report != null);
BarChartViewModel = new ReportsBarChartViewModel(schedulerProvider, dataSource.Preferences, totalsObservable, navigationService);
IsLoadingObservable = isLoading.AsObservable().AsDriver(schedulerProvider);
StartDate = startDateSubject.AsObservable().AsDriver(schedulerProvider);
EndDate = endDateSubject.AsObservable().AsDriver(schedulerProvider);
SelectWorkspace = rxActionFactory.FromAsync(selectWorkspace);
WorkspaceNameObservable = workspaceSubject
.Select(workspace => workspace?.Name ?? string.Empty)
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
WorkspaceHasBillableFeatureEnabled = workspaceSubject
.Where(workspace => workspace != null)
.SelectMany(workspace => interactorFactory.GetWorkspaceFeaturesById(workspace.Id).Execute())
.Select(workspaceFeatures => workspaceFeatures.IsEnabled(WorkspaceFeatureId.Pro))
.StartWith(false)
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
CurrentDateRange = currentDateRangeStringSubject
.StartWith(Resources.ThisWeek)
.Where(text => !string.IsNullOrEmpty(text))
.Select(text => $"{text} ▾")
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
WorkspacesObservable = interactorFactory.ObserveAllWorkspaces().Execute()
.Select(list => list.Where(w => !w.IsInaccessible))
.Select(readOnlyWorkspaceSelectOptions)
.AsDriver(schedulerProvider);
DurationFormatObservable = dataSource.Preferences.Current
.Select(prefs => prefs.DurationFormat)
.AsDriver(schedulerProvider);
SegmentsObservable = segmentsSubject.CombineLatest(DurationFormatObservable, applyDurationFormat);
GroupedSegmentsObservable = SegmentsObservable.CombineLatest(DurationFormatObservable, groupSegments);
ShowEmptyStateObservable = SegmentsObservable.CombineLatest(IsLoadingObservable, shouldShowEmptyState);
}
public TimeEntriesLogViewModel(ITogglDataSource dataSource)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
this.dataSource = dataSource;
}
public IsBillableAvailableForWorkspaceInteractor(ITogglDataSource dataSource, long workspaceId)
: base(dataSource)
{
this.workspaceId = workspaceId;
}
public SettingsViewModel(
UserAgent userAgent,
IMailService mailService,
ITogglDataSource dataSource,
IDialogService dialogService,
IInteractorFactory interactorFactory,
IPlatformConstants platformConstants,
IUserPreferences userPreferences,
IOnboardingStorage onboardingStorage,
IMvxNavigationService navigationService,
IAnalyticsService analyticsService)
{
Ensure.Argument.IsNotNull(userAgent, nameof(userAgent));
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(mailService, nameof(mailService));
Ensure.Argument.IsNotNull(dialogService, nameof(dialogService));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(navigationService, nameof(navigationService));
Ensure.Argument.IsNotNull(platformConstants, nameof(platformConstants));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
this.userAgent = userAgent;
this.dataSource = dataSource;
this.mailService = mailService;
this.dialogService = dialogService;
this.interactorFactory = interactorFactory;
this.navigationService = navigationService;
this.platformConstants = platformConstants;
this.userPreferences = userPreferences;
this.onboardingStorage = onboardingStorage;
this.analyticsService = analyticsService;
disposeBag.Add(dataSource.SyncManager
.ProgressObservable
.Subscribe(async progress =>
{
IsRunningSync = IsLoggingOut == false && progress == SyncProgress.Syncing;
IsSynced = IsLoggingOut == false && progress == SyncProgress.Synced && await isSynced();
})
);
RateCommand = new MvxCommand(rate);
HelpCommand = new MvxCommand(help);
UpdateCommand = new MvxCommand(update);
BackCommand = new MvxAsyncCommand(back);
LogoutCommand = new MvxAsyncCommand(maybeLogout);
EditProfileCommand = new MvxCommand(editProfile);
EditSubscriptionCommand = new MvxCommand(editSubscription);
ToggleManualModeCommand = new MvxCommand(toggleManualMode);
SubmitFeedbackCommand = new MvxAsyncCommand(submitFeedback);
AboutCommand = new MvxAsyncCommand(openAboutPage);
ToggleAddMobileTagCommand = new MvxCommand(toggleAddMobileTag);
SelectDateFormatCommand = new MvxAsyncCommand(selectDateFormat);
SelectDurationFormatCommand = new MvxAsyncCommand(selectDurationFormat);
SelectBeginningOfWeekCommand = new MvxAsyncCommand(selectBeginningOfWeek);
PickWorkspaceCommand = new MvxAsyncCommand(pickDefaultWorkspace);
ToggleUseTwentyFourHourClockCommand = new MvxAsyncCommand(toggleUseTwentyFourHourClock);
SelectDefaultWorkspaceCommand = new MvxAsyncCommand <SelectableWorkspaceViewModel>(selectDefaultWorkspace);
}
public SettingsViewModel(
UserAgent userAgent,
IMailService mailService,
ITogglDataSource dataSource,
IDialogService dialogService,
IUserPreferences userPreferences,
IFeedbackService feedbackService,
IAnalyticsService analyticsService,
IInteractorFactory interactorFactory,
IPlatformConstants platformConstants,
IOnboardingStorage onboardingStorage,
IMvxNavigationService navigationService)
{
Ensure.Argument.IsNotNull(userAgent, nameof(userAgent));
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(mailService, nameof(mailService));
Ensure.Argument.IsNotNull(dialogService, nameof(dialogService));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(feedbackService, nameof(feedbackService));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(navigationService, nameof(navigationService));
Ensure.Argument.IsNotNull(platformConstants, nameof(platformConstants));
this.userAgent = userAgent;
this.dataSource = dataSource;
this.mailService = mailService;
this.dialogService = dialogService;
this.userPreferences = userPreferences;
this.feedbackService = feedbackService;
this.analyticsService = analyticsService;
this.interactorFactory = interactorFactory;
this.navigationService = navigationService;
this.platformConstants = platformConstants;
this.onboardingStorage = onboardingStorage;
IsSynced = dataSource.SyncManager.ProgressObservable.SelectMany(checkSynced);
IsRunningSync =
dataSource.SyncManager
.ProgressObservable
.Select(isRunningSync);
Name =
dataSource.User.Current
.Select(user => user.Fullname)
.DistinctUntilChanged();
Email =
dataSource.User.Current
.Select(user => user.Email.ToString())
.DistinctUntilChanged();
IsManualModeEnabled = userPreferences.IsManualModeEnabledObservable;
WorkspaceName =
dataSource.User.Current
.DistinctUntilChanged(user => user.DefaultWorkspaceId)
.SelectMany(_ => interactorFactory.GetDefaultWorkspace().Execute())
.Select(workspace => workspace.Name);
BeginningOfWeek =
dataSource.User.Current
.Select(user => user.BeginningOfWeek)
.DistinctUntilChanged()
.Select(beginningOfWeek => beginningOfWeek.ToString());
DateFormat =
dataSource.Preferences.Current
.Select(preferences => preferences.DateFormat.Localized)
.DistinctUntilChanged();
DurationFormat =
dataSource.Preferences.Current
.Select(preferences => preferences.DurationFormat)
.Select(DurationFormatToString.Convert)
.DistinctUntilChanged();
UseTwentyFourHourFormat =
dataSource.Preferences.Current
.Select(preferences => preferences.TimeOfDayFormat.IsTwentyFourHoursFormat)
.DistinctUntilChanged();
UserAvatar =
dataSource.User.Current
.Select(user => user.ImageUrl)
.DistinctUntilChanged()
.SelectMany(url => interactorFactory.GetUserAvatar(url).Execute());
Workspaces =
dataSource.User.Current
.DistinctUntilChanged(user => user.DefaultWorkspaceId)
.SelectMany(user => interactorFactory
.GetAllWorkspaces()
.Execute()
.Select(selectableWorkspacesFromWorkspaces(user))
);
LoggingOut = loggingOutSubject.AsObservable();
dataSource.User.Current
.Subscribe(user => currentUser = user)
.DisposedBy(disposeBag);
dataSource.Preferences.Current
.Subscribe(preferences => currentPreferences = preferences)
.DisposedBy(disposeBag);
IsRunningSync
.Subscribe(isSyncing => this.isSyncing = isSyncing)
.DisposedBy(disposeBag);
IsFeedbackSuccessViewShowing = isFeedbackSuccessViewShowing.AsObservable();
}
private void onDataSource(ITogglDataSource newDataSource)
{
newDataSource.SyncManager.ForceFullSync().Subscribe();
navigationService.ForkNavigate <MainTabBarViewModel, MainViewModel>();
}
public GetAllWorkspacesInteractor(ITogglDataSource dataSource)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
this.dataSource = dataSource;
}
public ObserveWorkspacesChangesInteractor(ITogglDataSource dataSource)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
this.dataSource = dataSource;
}
public MainTabBarViewModel(
ITimeService timeService,
ITogglDataSource dataSource,
IDialogService dialogService,
IRatingService ratingService,
IUserPreferences userPreferences,
IAnalyticsService analyticsService,
IBackgroundService backgroundService,
IInteractorFactory interactorFactory,
IOnboardingStorage onboardingStorage,
ISchedulerProvider schedulerProvider,
IPermissionsService permissionsService,
IMvxNavigationService navigationService,
IRemoteConfigService remoteConfigService,
ISuggestionProviderContainer suggestionProviders,
IIntentDonationService intentDonationService,
IAccessRestrictionStorage accessRestrictionStorage,
IStopwatchProvider stopwatchProvider,
IRxActionFactory rxActionFactory)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(dialogService, nameof(dialogService));
Ensure.Argument.IsNotNull(ratingService, nameof(ratingService));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(backgroundService, nameof(backgroundService));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(navigationService, nameof(navigationService));
Ensure.Argument.IsNotNull(permissionsService, nameof(permissionsService));
Ensure.Argument.IsNotNull(remoteConfigService, nameof(remoteConfigService));
Ensure.Argument.IsNotNull(suggestionProviders, nameof(suggestionProviders));
Ensure.Argument.IsNotNull(accessRestrictionStorage, nameof(accessRestrictionStorage));
Ensure.Argument.IsNotNull(intentDonationService, nameof(intentDonationService));
Ensure.Argument.IsNotNull(dialogService, nameof(dialogService));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(stopwatchProvider, nameof(stopwatchProvider));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
this.remoteConfigService = remoteConfigService;
this.stopwatchProvider = stopwatchProvider;
mainViewModel = new MainViewModel(
dataSource,
timeService,
ratingService,
userPreferences,
analyticsService,
onboardingStorage,
interactorFactory,
navigationService,
remoteConfigService,
suggestionProviders,
intentDonationService,
accessRestrictionStorage,
schedulerProvider,
stopwatchProvider,
rxActionFactory);
reportsViewModel = new ReportsViewModel(
dataSource,
timeService,
navigationService,
interactorFactory,
analyticsService,
dialogService,
intentDonationService,
schedulerProvider,
stopwatchProvider,
rxActionFactory);
calendarViewModel = new CalendarViewModel(
dataSource,
timeService,
dialogService,
userPreferences,
analyticsService,
backgroundService,
interactorFactory,
onboardingStorage,
schedulerProvider,
permissionsService,
navigationService,
stopwatchProvider,
rxActionFactory);
}
public WorkspaceHasFeatureInteractor(ITogglDataSource dataSource)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
DataSource = dataSource;
}
public MainViewModel(
ITogglDataSource dataSource,
ISyncManager syncManager,
ITimeService timeService,
IRatingService ratingService,
IUserPreferences userPreferences,
IAnalyticsService analyticsService,
IOnboardingStorage onboardingStorage,
IInteractorFactory interactorFactory,
INavigationService navigationService,
IRemoteConfigService remoteConfigService,
IAccessibilityService accessibilityService,
IUpdateRemoteConfigCacheService updateRemoteConfigCacheService,
IAccessRestrictionStorage accessRestrictionStorage,
ISchedulerProvider schedulerProvider,
IRxActionFactory rxActionFactory,
IPermissionsChecker permissionsChecker,
IBackgroundService backgroundService,
IPlatformInfo platformInfo,
IWidgetsService widgetsService)
: base(navigationService)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(syncManager, nameof(syncManager));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(ratingService, nameof(ratingService));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(remoteConfigService, nameof(remoteConfigService));
Ensure.Argument.IsNotNull(accessibilityService, nameof(accessibilityService));
Ensure.Argument.IsNotNull(updateRemoteConfigCacheService, nameof(updateRemoteConfigCacheService));
Ensure.Argument.IsNotNull(accessRestrictionStorage, nameof(accessRestrictionStorage));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(permissionsChecker, nameof(permissionsChecker));
Ensure.Argument.IsNotNull(backgroundService, nameof(backgroundService));
Ensure.Argument.IsNotNull(platformInfo, nameof(platformInfo));
Ensure.Argument.IsNotNull(widgetsService, nameof(widgetsService));
this.dataSource = dataSource;
this.syncManager = syncManager;
this.platformInfo = platformInfo;
this.userPreferences = userPreferences;
this.rxActionFactory = rxActionFactory;
this.analyticsService = analyticsService;
this.interactorFactory = interactorFactory;
this.schedulerProvider = schedulerProvider;
this.accessibilityService = accessibilityService;
this.accessRestrictionStorage = accessRestrictionStorage;
this.widgetsService = widgetsService;
TimeService = timeService;
OnboardingStorage = onboardingStorage;
SuggestionsViewModel = new SuggestionsViewModel(interactorFactory, OnboardingStorage, schedulerProvider, rxActionFactory, analyticsService, timeService, permissionsChecker, navigationService, backgroundService, userPreferences, syncManager, widgetsService);
RatingViewModel = new RatingViewModel(timeService, ratingService, analyticsService, OnboardingStorage, navigationService, schedulerProvider, rxActionFactory);
TimeEntriesViewModel = new TimeEntriesViewModel(dataSource, interactorFactory, analyticsService, schedulerProvider, rxActionFactory, timeService);
TimeEntries = TimeEntriesViewModel.TimeEntries
.Throttle(TimeSpan.FromSeconds(throttlePeriodInSeconds))
.AsDriver(ImmutableList <MainLogSection> .Empty, schedulerProvider);
LogEmpty = TimeEntriesViewModel.Empty.AsDriver(schedulerProvider);
TimeEntriesCount = TimeEntriesViewModel.Count.AsDriver(schedulerProvider);
ratingViewExperiment = new RatingViewExperiment(timeService, dataSource, onboardingStorage, remoteConfigService, updateRemoteConfigCacheService);
SwipeActionsEnabled = userPreferences.SwipeActionsEnabled.AsDriver(schedulerProvider);
}
public StartTimeEntryViewModel(
ITimeService timeService,
ITogglDataSource dataSource,
IUserPreferences userPreferences,
IOnboardingStorage onboardingStorage,
IInteractorFactory interactorFactory,
INavigationService navigationService,
IAnalyticsService analyticsService,
ISchedulerProvider schedulerProvider,
IRxActionFactory rxActionFactory)
: base(navigationService)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
this.timeService = timeService;
this.userPreferences = userPreferences;
this.interactorFactory = interactorFactory;
this.analyticsService = analyticsService;
this.schedulerProvider = schedulerProvider;
DataSource = dataSource;
OnboardingStorage = onboardingStorage;
TextFieldInfo = textFieldInfo.AsDriver(schedulerProvider);
IsBillable = isBillable.AsDriver(schedulerProvider);
IsSuggestingTags = isSuggestingTags.AsDriver(schedulerProvider);
IsSuggestingProjects = isSuggestingProjects.AsDriver(schedulerProvider);
IsBillableAvailable = isBillableAvailable.AsDriver(schedulerProvider);
DisplayedTime = displayedTime
.Select(time => time.ToFormattedString(DurationFormat.Improved))
.AsDriver(schedulerProvider);
Done = rxActionFactory.FromObservable <IThreadSafeTimeEntry>(done);
DurationTapped = rxActionFactory.FromAction(durationTapped);
ToggleBillable = rxActionFactory.FromAction(toggleBillable);
SetStartDate = rxActionFactory.FromAsync(setStartDate);
ChangeTime = rxActionFactory.FromAsync(changeTime);
ToggleTagSuggestions = rxActionFactory.FromAction(toggleTagSuggestions);
ToggleProjectSuggestions = rxActionFactory.FromAction(toggleProjectSuggestions);
SelectSuggestion = rxActionFactory.FromAsync <AutocompleteSuggestion>(selectSuggestion);
SetRunningTime = rxActionFactory.FromAction <TimeSpan>(setRunningTime);
ToggleTasks = rxActionFactory.FromAction <ProjectSuggestion>(toggleTasks);
SetTextSpans = rxActionFactory.FromAction <IImmutableList <ISpan> >(setTextSpans);
var queryByType = queryByTypeSubject
.AsObservable()
.Select(type => new QueryInfo("", type));
var queryByText = textFieldInfo
.SelectMany(setBillableValues)
.Select(QueryInfo.ParseFieldInfo)
.Do(onParsedQuery)
.ObserveOn(schedulerProvider.BackgroundScheduler);
Suggestions = Observable.Merge(queryByText, queryByType)
.SelectMany(query => interactorFactory.GetAutocompleteSuggestions(query).Execute())
.Select(items => items.ToList()) // This is line is needed for now to read objects from realm .ObserveOn(schedulerProvider.BackgroundScheduler)
.Select(filter)
.Select(group)
.CombineLatest(expandedProjects, (groups, _) => groups)
.Select(toCollections)
.Select(addStaticElements)
.AsDriver(schedulerProvider);
}
public SettingsViewModel(
ITogglDataSource dataSource,
ISyncManager syncManager,
IPlatformInfo platformInfo,
IUserPreferences userPreferences,
IAnalyticsService analyticsService,
IInteractorFactory interactorFactory,
IOnboardingStorage onboardingStorage,
INavigationService navigationService,
IRxActionFactory rxActionFactory,
IPermissionsChecker permissionsChecker,
ISchedulerProvider schedulerProvider)
: base(navigationService)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(syncManager, nameof(syncManager));
Ensure.Argument.IsNotNull(platformInfo, nameof(platformInfo));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(permissionsChecker, nameof(permissionsChecker));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
this.dataSource = dataSource;
this.syncManager = syncManager;
this.platformInfo = platformInfo;
this.userPreferences = userPreferences;
this.analyticsService = analyticsService;
this.interactorFactory = interactorFactory;
this.onboardingStorage = onboardingStorage;
this.permissionsChecker = permissionsChecker;
IsSynced =
syncManager.ProgressObservable
.SelectMany(checkSynced)
.AsDriver(schedulerProvider);
IsRunningSync =
syncManager.ProgressObservable
.Select(isRunningSync)
.AsDriver(schedulerProvider);
Name =
dataSource.User.Current
.Select(user => user.Fullname)
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
Email =
dataSource.User.Current
.Select(user => user.Email.ToString())
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
IsManualModeEnabled = userPreferences.IsManualModeEnabledObservable
.AsDriver(schedulerProvider);
AreRunningTimerNotificationsEnabled = userPreferences.AreRunningTimerNotificationsEnabledObservable
.AsDriver(schedulerProvider);
AreStoppedTimerNotificationsEnabled = userPreferences.AreStoppedTimerNotificationsEnabledObservable
.AsDriver(schedulerProvider);
WorkspaceName =
dataSource.User.Current
.DistinctUntilChanged(user => user.DefaultWorkspaceId)
.SelectMany(_ => interactorFactory.GetDefaultWorkspace()
.TrackException <InvalidOperationException, IThreadSafeWorkspace>("SettingsViewModel.constructor")
.Execute()
)
.Select(workspace => workspace.Name)
.AsDriver(schedulerProvider);
BeginningOfWeek =
dataSource.User.Current
.Select(user => user.BeginningOfWeek)
.DistinctUntilChanged()
.Select(beginningOfWeek => beginningOfWeek.ToLocalizedString())
.AsDriver(schedulerProvider);
DateFormat =
dataSource.Preferences.Current
.Select(preferences => preferences.DateFormat.Localized)
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
DurationFormat =
dataSource.Preferences.Current
.Select(preferences => preferences.DurationFormat.ToFormattedString())
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
UseTwentyFourHourFormat =
dataSource.Preferences.Current
.Select(preferences => preferences.TimeOfDayFormat.IsTwentyFourHoursFormat)
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
IsGroupingTimeEntries =
dataSource.Preferences.Current
.Select(preferences => preferences.CollapseTimeEntries)
.DistinctUntilChanged()
.AsDriver(false, schedulerProvider);
IsCalendarSmartRemindersVisible = calendarPermissionGranted.AsObservable()
.CombineLatest(userPreferences.EnabledCalendars.Select(ids => ids.Any()), CommonFunctions.And);
CalendarSmartReminders = userPreferences.CalendarNotificationsSettings()
.Select(s => s.Title())
.DistinctUntilChanged();
LoggingOut = loggingOutSubject.AsObservable()
.AsDriver(schedulerProvider);
PresentableSyncStatus combineStatuses(bool synced, bool syncing, bool loggingOut)
{
if (loggingOut)
{
return(PresentableSyncStatus.LoggingOut);
}
return(syncing ? PresentableSyncStatus.Syncing : PresentableSyncStatus.Synced);
}
CurrentSyncStatus = Observable.CombineLatest(
IsSynced,
IsRunningSync,
LoggingOut.SelectValue(true).StartWith(false),
combineStatuses);
dataSource.User.Current
.Subscribe(user => currentUser = user)
.DisposedBy(disposeBag);
dataSource.Preferences.Current
.Subscribe(preferences => currentPreferences = preferences)
.DisposedBy(disposeBag);
IsRunningSync
.Subscribe(isSyncing => this.isSyncing = isSyncing)
.DisposedBy(disposeBag);
IsFeedbackSuccessViewShowing = isFeedbackSuccessViewShowing.AsObservable()
.AsDriver(schedulerProvider);
SwipeActionsEnabled = userPreferences.SwipeActionsEnabled
.AsDriver(schedulerProvider);
OpenCalendarSettings = rxActionFactory.FromAsync(openCalendarSettings);
OpenCalendarSmartReminders = rxActionFactory.FromAsync(openCalendarSmartReminders);
OpenNotificationSettings = rxActionFactory.FromAsync(openNotificationSettings);
ToggleTwentyFourHourSettings = rxActionFactory.FromAsync(toggleUseTwentyFourHourClock);
OpenHelpView = rxActionFactory.FromAsync(openHelpView);
TryLogout = rxActionFactory.FromAsync(tryLogout);
OpenAboutView = rxActionFactory.FromAsync(openAboutView);
OpenSiriShortcuts = rxActionFactory.FromAsync(openSiriShorcuts);
OpenSiriWorkflows = rxActionFactory.FromAsync(openSiriWorkflows);
SubmitFeedback = rxActionFactory.FromAsync(submitFeedback);
SelectDateFormat = rxActionFactory.FromAsync(selectDateFormat);
PickDefaultWorkspace = rxActionFactory.FromAsync(pickDefaultWorkspace);
SelectDurationFormat = rxActionFactory.FromAsync(selectDurationFormat);
SelectBeginningOfWeek = rxActionFactory.FromAsync(selectBeginningOfWeek);
ToggleTimeEntriesGrouping = rxActionFactory.FromAsync(toggleTimeEntriesGrouping);
ToggleManualMode = rxActionFactory.FromAction(toggleManualMode);
ToggleSwipeActions = rxActionFactory.FromAction(toggleSwipeActions);
}
public MainTabBarViewModel(
ITimeService timeService,
ITogglDataSource dataSource,
ISyncManager syncManager,
IRatingService ratingService,
IUserPreferences userPreferences,
IAnalyticsService analyticsService,
IBackgroundService backgroundService,
IInteractorFactory interactorFactory,
IOnboardingStorage onboardingStorage,
ISchedulerProvider schedulerProvider,
IPermissionsChecker permissionsChecker,
INavigationService navigationService,
IRemoteConfigService remoteConfigService,
IAccessibilityService accessibilityService,
IUpdateRemoteConfigCacheService updateRemoteConfigCacheService,
IAccessRestrictionStorage accessRestrictionStorage,
IRxActionFactory rxActionFactory,
IUserAccessManager userAccessManager,
IPrivateSharedStorageService privateSharedStorageService,
IPlatformInfo platformInfo,
IWidgetsService widgetsService)
: base(navigationService)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(syncManager, nameof(syncManager));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(ratingService, nameof(ratingService));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(backgroundService, nameof(backgroundService));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(onboardingStorage, nameof(onboardingStorage));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(permissionsChecker, nameof(permissionsChecker));
Ensure.Argument.IsNotNull(remoteConfigService, nameof(remoteConfigService));
Ensure.Argument.IsNotNull(accessibilityService, nameof(accessibilityService));
Ensure.Argument.IsNotNull(updateRemoteConfigCacheService, nameof(updateRemoteConfigCacheService));
Ensure.Argument.IsNotNull(accessRestrictionStorage, nameof(accessRestrictionStorage));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(userAccessManager, nameof(userAccessManager));
Ensure.Argument.IsNotNull(privateSharedStorageService, nameof(privateSharedStorageService));
Ensure.Argument.IsNotNull(platformInfo, nameof(platformInfo));
Ensure.Argument.IsNotNull(widgetsService, nameof(widgetsService));
this.remoteConfigService = remoteConfigService;
this.platformInfo = platformInfo;
mainViewModel = new MainViewModel(
dataSource,
syncManager,
timeService,
ratingService,
userPreferences,
analyticsService,
onboardingStorage,
interactorFactory,
navigationService,
remoteConfigService,
accessibilityService,
updateRemoteConfigCacheService,
accessRestrictionStorage,
schedulerProvider,
rxActionFactory,
permissionsChecker,
backgroundService,
platformInfo,
widgetsService);
reportsViewModel = new ReportsViewModel(
dataSource,
timeService,
navigationService,
interactorFactory,
analyticsService,
schedulerProvider,
rxActionFactory);
calendarViewModel = new CalendarViewModel(
dataSource,
timeService,
userPreferences,
analyticsService,
backgroundService,
interactorFactory,
onboardingStorage,
schedulerProvider,
permissionsChecker,
navigationService,
rxActionFactory);
settingsViewModel = new SettingsViewModel(
dataSource,
syncManager,
platformInfo,
userPreferences,
analyticsService,
interactorFactory,
onboardingStorage,
navigationService,
rxActionFactory,
permissionsChecker,
schedulerProvider);
Tabs = getViewModels().ToList();
}
