private static void configurePullTransitions(
TransitionHandlerProvider transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
ITimeService timeService,
StateResult entryPoint)
{
var fetchAllSince = new FetchAllSinceState(database, api, timeService);
var persistWorkspaces = new PersistWorkspacesState(database.Workspaces, database.SinceParameters);
var persistWorkspaceFeatures = new PersistWorkspacesFeaturesState(database.WorkspaceFeatures, database.SinceParameters);
var persistTags = new PersistTagsState(database.Tags, database.SinceParameters);
var persistClients = new PersistClientsState(database.Clients, database.SinceParameters);
var persistProjects = new PersistProjectsState(database.Projects, database.SinceParameters);
var persistTimeEntries = new PersistTimeEntriesState(dataSource.TimeEntries, database.SinceParameters, timeService);
var persistTasks = new PersistTasksState(database.Tasks, database.SinceParameters);
transitions.ConfigureTransition(entryPoint, fetchAllSince.Start);
transitions.ConfigureTransition(fetchAllSince.FetchStarted, persistWorkspaces.Start);
transitions.ConfigureTransition(persistWorkspaces.FinishedPersisting, persistWorkspaceFeatures.Start);
transitions.ConfigureTransition(persistWorkspaceFeatures.FinishedPersisting, persistTags.Start);
transitions.ConfigureTransition(persistTags.FinishedPersisting, persistClients.Start);
transitions.ConfigureTransition(persistClients.FinishedPersisting, persistProjects.Start);
transitions.ConfigureTransition(persistProjects.FinishedPersisting, persistTasks.Start);
transitions.ConfigureTransition(persistTasks.FinishedPersisting, persistTimeEntries.Start);
}
internal FoundationMvvmCross(
IApiFactory apiFactory,
ITogglDatabase database,
ITimeService timeService,
IScheduler scheduler,
IAnalyticsService analyticsService,
IGoogleService googleService,
IApplicationShortcutCreator shortcutCreator,
IBackgroundService backgroundService,
IOnboardingStorage onboardingStorage,
IAccessRestrictionStorage accessRestrictionStorage,
IMvxNavigationService navigationService,
IApiErrorHandlingService apiErrorHandlingService)
{
Database = database;
ApiFactory = apiFactory;
TimeService = timeService;
Scheduler = scheduler;
AnalyticsService = analyticsService;
GoogleService = googleService;
ShortcutCreator = shortcutCreator;
BackgroundService = backgroundService;
OnboardingStorage = onboardingStorage;
AccessRestrictionStorage = accessRestrictionStorage;
NavigationService = navigationService;
ApiErrorHandlingService = apiErrorHandlingService;
}
public LogoutInteractor(
IAnalyticsService analyticsService,
INotificationService notificationService,
IApplicationShortcutCreator shortcutCreator,
ISyncManager syncManager,
ITogglDatabase database,
IUserPreferences userPreferences,
IPrivateSharedStorageService privateSharedStorageService,
IUserAccessManager userAccessManager,
LogoutSource source)
{
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(notificationService, nameof(notificationService));
Ensure.Argument.IsNotNull(shortcutCreator, nameof(shortcutCreator));
Ensure.Argument.IsNotNull(syncManager, nameof(syncManager));
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(privateSharedStorageService, nameof(privateSharedStorageService));
Ensure.Argument.IsNotNull(userAccessManager, nameof(userAccessManager));
Ensure.Argument.IsADefinedEnumValue(source, nameof(source));
this.analyticsService = analyticsService;
this.shortcutCreator = shortcutCreator;
this.notificationService = notificationService;
this.syncManager = syncManager;
this.database = database;
this.userPreferences = userPreferences;
this.privateSharedStorageService = privateSharedStorageService;
this.userAccessManager = userAccessManager;
this.source = source;
}
private static IStateResult configurePushTransitionsForTimeEntries(
TransitionHandlerProvider transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
IScheduler scheduler,
IStateResult entryPoint,
IObservable <Unit> delayCancellation)
{
var rnd = new Random();
var apiDelay = new RetryDelayService(rnd);
var statusDelay = new RetryDelayService(rnd);
var push = new PushTimeEntriesState(database.TimeEntries);
var pushOne = new PushOneEntityState <IDatabaseTimeEntry>();
var create = new CreateTimeEntryState(api, dataSource.TimeEntries);
var update = new UpdateTimeEntryState(api, dataSource.TimeEntries);
var delete = new DeleteTimeEntryState(api, database.TimeEntries);
var deleteLocal = new DeleteLocalTimeEntryState(database.TimeEntries);
var unsyncable = new UnsyncableTimeEntryState(dataSource.TimeEntries);
var checkServerStatus = new CheckServerStatusState(api, scheduler, apiDelay, statusDelay, delayCancellation);
var finished = new ResetAPIDelayState(apiDelay);
return(configurePush(transitions, entryPoint, push, pushOne, create, update, delete, deleteLocal, unsyncable, checkServerStatus, finished));
}
public AppServices(ITogglApi api, ITogglDatabase database)
{
Scheduler = System.Reactive.Concurrency.Scheduler.Default;
TimeService = new TimeService(Scheduler);
var errorHandlingService = new ErrorHandlingService(NavigationServiceSubstitute, AccessRestrictionStorageSubsitute);
syncErrorHandlingService = new SyncErrorHandlingService(errorHandlingService);
ISyncManager createSyncManager(ITogglDataSource dataSource)
{
var syncManager = TogglSyncManager.CreateSyncManager(
database,
api,
dataSource,
TimeService,
AnalyticsServiceSubstitute,
LastTimeUsageStorageSubstitute,
Scheduler,
StopwatchProvider);
syncErrorHandlingService.HandleErrorsOf(syncManager);
return(syncManager);
}
var togglDataSource = new TogglDataSource(
api,
database,
TimeService,
createSyncManager,
AnalyticsServiceSubstitute);
SyncManager = togglDataSource.SyncManager;
}
public InteractorFactory(
IIdProvider idProvider,
ITogglDatabase database,
ITimeService timeService,
ITogglDataSource dataSource,
IUserPreferences userPreferences,
IAnalyticsService analyticsService,
IApplicationShortcutCreator shortcutCreator)
{
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(idProvider, nameof(idProvider));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(shortcutCreator, nameof(shortcutCreator));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
this.database = database;
this.dataSource = dataSource;
this.idProvider = idProvider;
this.timeService = timeService;
this.userPreferences = userPreferences;
this.shortcutCreator = shortcutCreator;
this.analyticsService = analyticsService;
}
public LoginManager(
IApiFactory apiFactory,
ITogglDatabase database,
IGoogleService googleService,
IApplicationShortcutCreator shortcutCreator,
IAccessRestrictionStorage accessRestrictionStorage,
IAnalyticsService analyticsService,
IPrivateSharedStorageService privateSharedStorageService,
Func <ITogglApi, ITogglDataSource> createDataSource,
IScheduler scheduler
)
{
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(apiFactory, nameof(apiFactory));
Ensure.Argument.IsNotNull(accessRestrictionStorage, nameof(accessRestrictionStorage));
Ensure.Argument.IsNotNull(googleService, nameof(googleService));
Ensure.Argument.IsNotNull(shortcutCreator, nameof(shortcutCreator));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(privateSharedStorageService, nameof(privateSharedStorageService));
Ensure.Argument.IsNotNull(createDataSource, nameof(createDataSource));
Ensure.Argument.IsNotNull(scheduler, nameof(scheduler));
this.database = database;
this.apiFactory = apiFactory;
this.accessRestrictionStorage = accessRestrictionStorage;
this.googleService = googleService;
this.analyticsService = analyticsService;
this.privateSharedStorageService = privateSharedStorageService;
this.shortcutCreator = shortcutCreator;
this.createDataSource = createDataSource;
this.scheduler = scheduler;
}
public ProjectDefaultsToBillableInteractor(ITogglDatabase database, long projectId)
{
Ensure.Argument.IsNotNull(database, nameof(database));
this.projectId = projectId;
this.database = database;
}
public TogglDataSource(
ITogglApi api,
ITogglDatabase database,
ITimeService timeService,
Func <ITogglDataSource, ISyncManager> createSyncManager,
IAnalyticsService analyticsService)
{
Ensure.Argument.IsNotNull(api, nameof(api));
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(createSyncManager, nameof(createSyncManager));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
this.database = database;
User = new UserDataSource(database.User);
Tags = new TagsDataSource(database.Tags);
Tasks = new TasksDataSource(database.Tasks);
Clients = new ClientsDataSource(database.Clients);
Projects = new ProjectsDataSource(database.Projects);
Workspaces = new WorkspacesDataSource(database.Workspaces);
Preferences = new PreferencesDataSource(database.Preferences);
WorkspaceFeatures = new WorkspaceFeaturesDataSource(database.WorkspaceFeatures);
TimeEntries = new TimeEntriesDataSource(database.TimeEntries, timeService, analyticsService);
SyncManager = createSyncManager(this);
ReportsProvider = new ReportsProvider(api, database);
FeedbackApi = api.Feedback;
}
public GetWorkspaceByIdInteractor(ITogglDatabase database, long workspaceId)
{
Ensure.Argument.IsNotNull(database, nameof(database));
this.database = database;
this.workspaceId = workspaceId;
}
public AppServices(ITogglApi api, ITogglDatabase database)
{
Scheduler = System.Reactive.Concurrency.Scheduler.Default;
TimeService = new TimeService(Scheduler);
var errorHandlingService = new ErrorHandlingService(NavigationServiceSubstitute, AccessRestrictionStorageSubsitute);
syncErrorHandlingService = new SyncErrorHandlingService(errorHandlingService);
var dataSource = new TogglDataSource(
database,
TimeService,
AnalyticsServiceSubstitute);
SyncManager = TogglSyncManager.CreateSyncManager(
database,
api,
dataSource,
TimeService,
AnalyticsServiceSubstitute,
LastTimeUsageStorageSubstitute,
Scheduler,
AutomaticSyncingService);
syncErrorHandlingService.HandleErrorsOf(SyncManager);
}
public LoginManager(IApiFactory apiFactory, ITogglDatabase database)
{
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(apiFactory, nameof(apiFactory));
this.database = database;
this.apiFactory = apiFactory;
}
public TheStartMethod()
{
database = Substitute.For <ITogglDatabase>();
api = Substitute.For <ITogglApi>();
timeService = Substitute.For <ITimeService>();
timeService.CurrentDateTime.Returns(DateTimeOffset.Now);
state = new FetchAllSinceState(database, api, timeService);
}
public MostUsedTimeEntryProvider(ITogglDatabase database, ITimeService timeService)
{
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
this.database = database;
this.timeService = timeService;
}
public InteractorFactory(
IIdProvider idProvider,
ITimeService timeService,
ITogglDataSource dataSource,
ITogglApi api,
IUserPreferences userPreferences,
IAnalyticsService analyticsService,
INotificationService notificationService,
IIntentDonationService intentDonationService,
IApplicationShortcutCreator shortcutCreator,
ILastTimeUsageStorage lastTimeUsageStorage,
IPlatformInfo platformInfo,
UserAgent userAgent,
ICalendarService calendarService,
ISyncManager syncManager,
IStopwatchProvider stopwatchProvider,
ITogglDatabase database,
IPrivateSharedStorageService privateSharedStorageService,
IUserAccessManager userAccessManager)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(api, nameof(api));
Ensure.Argument.IsNotNull(idProvider, nameof(idProvider));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(userPreferences, nameof(userPreferences));
Ensure.Argument.IsNotNull(shortcutCreator, nameof(shortcutCreator));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(notificationService, nameof(notificationService));
Ensure.Argument.IsNotNull(intentDonationService, nameof(intentDonationService));
Ensure.Argument.IsNotNull(lastTimeUsageStorage, nameof(lastTimeUsageStorage));
Ensure.Argument.IsNotNull(platformInfo, nameof(platformInfo));
Ensure.Argument.IsNotNull(userAgent, nameof(userAgent));
Ensure.Argument.IsNotNull(calendarService, nameof(calendarService));
Ensure.Argument.IsNotNull(syncManager, nameof(syncManager));
Ensure.Argument.IsNotNull(stopwatchProvider, nameof(stopwatchProvider));
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(privateSharedStorageService, nameof(privateSharedStorageService));
Ensure.Argument.IsNotNull(userAccessManager, nameof(userAccessManager));
this.dataSource = dataSource;
this.api = api;
this.idProvider = idProvider;
this.timeService = timeService;
this.userPreferences = userPreferences;
this.shortcutCreator = shortcutCreator;
this.analyticsService = analyticsService;
this.notificationService = notificationService;
this.intentDonationService = intentDonationService;
this.lastTimeUsageStorage = lastTimeUsageStorage;
this.platformInfo = platformInfo;
this.userAgent = userAgent;
this.calendarService = calendarService;
this.syncManager = syncManager;
this.stopwatchProvider = stopwatchProvider;
this.database = database;
this.privateSharedStorageService = privateSharedStorageService;
this.userAccessManager = userAccessManager;
}
public ReportsProvider(ITogglApi api, ITogglDatabase database)
{
Ensure.Argument.IsNotNull(api, nameof(api));
Ensure.Argument.IsNotNull(database, nameof(database));
projectsApi = api.Projects;
projectsRepository = database.Projects;
projectSummaryApi = api.ProjectsSummary;
}
public MostUsedTimeEntrySuggestionProvider(ITogglDatabase database,
ITimeService timeService, int maxNumberOfSuggestions)
{
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
this.database = database;
this.timeService = timeService;
this.maxNumberOfSuggestions = maxNumberOfSuggestions;
}
private static void configurePushTransitions(
TransitionHandlerProvider transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
IScheduler scheduler,
StateResult entryPoint)
{
configurePushTransitionsForTimeEntries(transitions, database, api, dataSource, scheduler, entryPoint);
}
public TogglDataSource(ITogglDatabase database, ITogglApi api)
{
Ensure.Argument.IsNotNull(api, nameof(api));
Ensure.Argument.IsNotNull(database, nameof(database));
this.database = database;
User = new UserDataSource(database.User, api.User);
Projects = new ProjectsDataSource(database.Projects);
TimeEntries = new TimeEntriesDataSource(database.IdProvider, database.TimeEntries);
}
public static void ConfigureTransitions(
TransitionHandlerProvider transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
IScheduler scheduler,
ITimeService timeService,
StateMachineEntryPoints entryPoints)
{
configurePullTransitions(transitions, database, api, dataSource, timeService, entryPoints.StartPullSync);
configurePushTransitions(transitions, database, api, dataSource, scheduler, entryPoints.StartPushSync);
}
public LoginManager(IApiFactory apiFactory, ITogglDatabase database, ITimeService timeService, IScheduler scheduler)
{
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(apiFactory, nameof(apiFactory));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(scheduler, nameof(scheduler));
this.database = database;
this.apiFactory = apiFactory;
this.timeService = timeService;
this.scheduler = scheduler;
}
private static void configurePullTransitions(
TransitionHandlerProvider transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
ITimeService timeService,
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 PersistWorkspacesState(database.Workspaces, database.SinceParameters);
var persistWorkspaceFeatures = new PersistWorkspacesFeaturesState(database.WorkspaceFeatures, database.SinceParameters);
var persistUser = new PersistUserState(database.User, database.SinceParameters);
var persistTags = new PersistTagsState(database.Tags, database.SinceParameters);
var persistClients = new PersistClientsState(database.Clients, database.SinceParameters);
var persistPreferences = new PersistPreferencesState(dataSource.Preferences, database.SinceParameters);
var persistProjects = new PersistProjectsState(database.Projects, database.SinceParameters);
var persistTimeEntries = new PersistTimeEntriesState(dataSource.TimeEntries, database.SinceParameters, timeService);
var persistTasks = new PersistTasksState(database.Tasks, database.SinceParameters);
var checkServerStatus = new CheckServerStatusState(api, scheduler, apiDelay, statusDelay, delayCancellation);
var finished = new ResetAPIDelayState(apiDelay);
transitions.ConfigureTransition(entryPoint, fetchAllSince.Start);
transitions.ConfigureTransition(fetchAllSince.FetchStarted, persistWorkspaces.Start);
transitions.ConfigureTransition(persistWorkspaces.FinishedPersisting, persistUser.Start);
transitions.ConfigureTransition(persistUser.FinishedPersisting, persistWorkspaceFeatures.Start);
transitions.ConfigureTransition(persistWorkspaceFeatures.FinishedPersisting, persistPreferences.Start);
transitions.ConfigureTransition(persistPreferences.FinishedPersisting, persistTags.Start);
transitions.ConfigureTransition(persistTags.FinishedPersisting, persistClients.Start);
transitions.ConfigureTransition(persistClients.FinishedPersisting, persistProjects.Start);
transitions.ConfigureTransition(persistProjects.FinishedPersisting, persistTasks.Start);
transitions.ConfigureTransition(persistTasks.FinishedPersisting, persistTimeEntries.Start);
transitions.ConfigureTransition(persistWorkspaces.Failed, checkServerStatus.Start);
transitions.ConfigureTransition(persistWorkspaceFeatures.Failed, checkServerStatus.Start);
transitions.ConfigureTransition(persistPreferences.Failed, checkServerStatus.Start);
transitions.ConfigureTransition(persistTags.Failed, checkServerStatus.Start);
transitions.ConfigureTransition(persistClients.Failed, checkServerStatus.Start);
transitions.ConfigureTransition(persistProjects.Failed, checkServerStatus.Start);
transitions.ConfigureTransition(persistTasks.Failed, checkServerStatus.Start);
transitions.ConfigureTransition(persistTimeEntries.Failed, checkServerStatus.Start);
transitions.ConfigureTransition(checkServerStatus.Retry, checkServerStatus.Start);
transitions.ConfigureTransition(checkServerStatus.ServerIsAvailable, finished.Start);
transitions.ConfigureTransition(finished.Continue, fetchAllSince.Start);
}
public static Foundation Create(
string clientName,
string version,
ITogglDatabase database,
ITimeService timeService,
IScheduler scheduler,
IMailService mailService,
IGoogleService googleService,
ApiEnvironment apiEnvironment,
ILicenseProvider licenseProvider,
IAnalyticsService analyticsService,
IPlatformConstants platformConstants,
IApplicationShortcutCreator shortcutCreator,
ISuggestionProviderContainer suggestionProviderContainer)
{
Ensure.Argument.IsNotNull(version, nameof(version));
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(clientName, nameof(clientName));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(scheduler, nameof(scheduler));
Ensure.Argument.IsNotNull(mailService, nameof(mailService));
Ensure.Argument.IsNotNull(googleService, nameof(googleService));
Ensure.Argument.IsNotNull(licenseProvider, nameof(licenseProvider));
Ensure.Argument.IsNotNull(shortcutCreator, nameof(shortcutCreator));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
Ensure.Argument.IsNotNull(platformConstants, nameof(platformConstants));
Ensure.Argument.IsNotNull(suggestionProviderContainer, nameof(suggestionProviderContainer));
var userAgent = new UserAgent(clientName, version.ToString());
var foundation = new Foundation
{
Database = database,
UserAgent = userAgent,
TimeService = timeService,
Scheduler = scheduler,
MailService = mailService,
GoogleService = googleService,
ApiEnvironment = apiEnvironment,
LicenseProvider = licenseProvider,
Version = Version.Parse(version),
ShortcutCreator = shortcutCreator,
AnalyticsService = analyticsService,
PlatformConstants = platformConstants,
BackgroundService = new BackgroundService(timeService),
ApiFactory = new ApiFactory(apiEnvironment, userAgent),
SuggestionProviderContainer = suggestionProviderContainer
};
return(foundation);
}
public static void ConfigureTransitions(
TransitionHandlerProvider transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
IRetryDelayService apiDelay,
IScheduler scheduler,
ITimeService timeService,
StateMachineEntryPoints entryPoints,
IObservable <Unit> delayCancellation)
{
configurePullTransitions(transitions, database, api, dataSource, timeService, scheduler, entryPoints.StartPullSync, delayCancellation);
configurePushTransitions(transitions, database, api, dataSource, apiDelay, scheduler, entryPoints.StartPushSync, delayCancellation);
}
public TogglDataSource(
ITogglApi api,
ITogglDatabase database,
ITimeService timeService,
IErrorHandlingService errorHandlingService,
IBackgroundService backgroundService,
Func <ITogglDataSource, ISyncManager> createSyncManager,
TimeSpan minimumTimeInBackgroundForFullSync,
INotificationService notificationService,
IApplicationShortcutCreator shortcutCreator,
IAnalyticsService analyticsService)
{
Ensure.Argument.IsNotNull(api, nameof(api));
Ensure.Argument.IsNotNull(database, nameof(database));
Ensure.Argument.IsNotNull(timeService, nameof(timeService));
Ensure.Argument.IsNotNull(notificationService, nameof(notificationService));
Ensure.Argument.IsNotNull(errorHandlingService, nameof(errorHandlingService));
Ensure.Argument.IsNotNull(backgroundService, nameof(backgroundService));
Ensure.Argument.IsNotNull(createSyncManager, nameof(createSyncManager));
Ensure.Argument.IsNotNull(shortcutCreator, nameof(shortcutCreator));
Ensure.Argument.IsNotNull(analyticsService, nameof(analyticsService));
this.database = database;
this.timeService = timeService;
this.shortcutCreator = shortcutCreator;
this.backgroundService = backgroundService;
this.notificationService = notificationService;
this.errorHandlingService = errorHandlingService;
this.minimumTimeInBackgroundForFullSync = minimumTimeInBackgroundForFullSync;
User = new UserDataSource(database.User);
Tags = new TagsDataSource(database.Tags);
Tasks = new TasksDataSource(database.Tasks);
Clients = new ClientsDataSource(database.Clients);
Projects = new ProjectsDataSource(database.Projects);
Workspaces = new WorkspacesDataSource(database.Workspaces);
Preferences = new PreferencesDataSource(database.Preferences);
WorkspaceFeatures = new WorkspaceFeaturesDataSource(database.WorkspaceFeatures);
TimeEntries = new TimeEntriesDataSource(database.TimeEntries, timeService, analyticsService);
this.createSyncManager = createSyncManager;
CreateNewSyncManager();
ReportsProvider = new ReportsProvider(api, database);
FeedbackApi = api.Feedback;
isLoggedIn = true;
}
public static void ConfigureTransitions(
ITransitionConfigurator transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
IRetryDelayService apiDelay,
IScheduler scheduler,
ITimeService timeService,
IAnalyticsService analyticsService,
StateMachineEntryPoints entryPoints,
IObservable <Unit> delayCancellation)
{
configurePullTransitions(transitions, database, api, dataSource, timeService, analyticsService, scheduler, entryPoints.StartPullSync, delayCancellation);
configurePushTransitions(transitions, api, dataSource, analyticsService, apiDelay, scheduler, entryPoints.StartPushSync, delayCancellation);
configureCleanUpTransitions(transitions, timeService, dataSource, entryPoints.StartCleanUp);
}
private static void configurePushTransitions(
TransitionHandlerProvider transitions,
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
IScheduler scheduler,
StateResult entryPoint,
IObservable <Unit> delayCancellation)
{
var pushingUsersFinished = configurePushTransitionsForUsers(transitions, database, api, scheduler, entryPoint, delayCancellation);
var pushingTagsFinished = configurePushTransitionsForTags(transitions, database, api, scheduler, pushingUsersFinished, delayCancellation);
var pushingClientsFinished = configurePushTransitionsForClients(transitions, database, api, scheduler, pushingTagsFinished, delayCancellation);
var pushingProjectsFinished = configurePushTransitionsForProjects(transitions, database, api, scheduler, pushingClientsFinished, delayCancellation);
configurePushTransitionsForTimeEntries(transitions, database, api, dataSource, scheduler, pushingProjectsFinished, delayCancellation);
}
private static void configurePullTimeEntriesTransitions(
ITransitionConfigurator transitions,
ITogglApi api,
ITogglDataSource dataSource,
ITogglDatabase database,
IAnalyticsService analyticsService,
ITimeService timeService,
ILeakyBucket leakyBucket,
IRateLimiter rateLimiter,
ILastTimeUsageStorage lastTimeUsageStorage,
StateResult entryPoint)
{
var fetchTimeEntries = new FetchJustTimeEntriesSinceState(api, database.SinceParameters, timeService, leakyBucket, rateLimiter);
var ensureFetchTimeEntriesSucceeded = new EnsureFetchListSucceededState <ITimeEntry>();
var placeholderStateFactory = new CreatePlaceholdersStateFactory(
dataSource,
analyticsService,
lastTimeUsageStorage,
timeService);
var createWorkspacePlaceholder = placeholderStateFactory.ForWorkspaces();
var createProjectPlaceholder = placeholderStateFactory.ForProjects();
var createTaskPlaceholder = placeholderStateFactory.ForTasks();
var createTagPlaceholder = placeholderStateFactory.ForTags();
var persistTimeEntries =
new PersistListState <ITimeEntry, IDatabaseTimeEntry, IThreadSafeTimeEntry>(dataSource.TimeEntries, TimeEntry.Clean);
var updateTimeEntriesSinceDate = new UpdateSinceDateState <ITimeEntry>(database.SinceParameters);
var timeEntriesAnalytics = new TimeEntriesAnalyticsState(analyticsService);
transitions.ConfigureTransition(entryPoint, fetchTimeEntries);
transitions.ConfigureTransition(fetchTimeEntries.PreventOverloadingServer, new DeadEndState());
transitions.ConfigureTransition(fetchTimeEntries.Done, ensureFetchTimeEntriesSucceeded);
transitions.ConfigureTransition(ensureFetchTimeEntriesSucceeded.ErrorOccured, new FailureState());
transitions.ConfigureTransition(ensureFetchTimeEntriesSucceeded.Done, timeEntriesAnalytics);
transitions.ConfigureTransition(timeEntriesAnalytics.Done, createWorkspacePlaceholder);
transitions.ConfigureTransition(createWorkspacePlaceholder.Done, createProjectPlaceholder);
transitions.ConfigureTransition(createProjectPlaceholder.Done, createTaskPlaceholder);
transitions.ConfigureTransition(createTaskPlaceholder.Done, createTagPlaceholder);
transitions.ConfigureTransition(createTagPlaceholder.Done, persistTimeEntries);
transitions.ConfigureTransition(persistTimeEntries.Done, updateTimeEntriesSinceDate);
transitions.ConfigureTransition(updateTimeEntriesSinceDate.Done, new DeadEndState());
}
public static ISyncManager CreateSyncManager(
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
ITimeService timeService,
IScheduler scheduler)
{
var queue = new SyncStateQueue();
var entryPoints = new StateMachineEntryPoints();
var transitions = new TransitionHandlerProvider();
ConfigureTransitions(transitions, database, api, dataSource, scheduler, timeService, entryPoints);
var stateMachine = new StateMachine(transitions, scheduler);
var orchestrator = new StateMachineOrchestrator(stateMachine, entryPoints);
return(new SyncManager(queue, orchestrator));
}
public static ISyncManager CreateSyncManager(
ITogglDatabase database,
ITogglApi api,
ITogglDataSource dataSource,
ITimeService timeService,
IScheduler scheduler)
{
var queue = new SyncStateQueue();
var entryPoints = new StateMachineEntryPoints();
var transitions = new TransitionHandlerProvider();
var delayCancellation = new Subject <Unit>();
var delayCancellationObservable = delayCancellation.AsObservable().Replay();
ConfigureTransitions(transitions, database, api, dataSource, scheduler, timeService, entryPoints, delayCancellationObservable);
var stateMachine = new StateMachine(transitions, scheduler, delayCancellation);
var orchestrator = new StateMachineOrchestrator(stateMachine, entryPoints);
return(new SyncManager(queue, orchestrator));
}
