public override async Task Initialize()
{
await base.Initialize();
navigationFromEditTimeEntryViewModelStopwatch = stopwatchProvider.Get(MeasuredOperation.OpenSelectProjectFromEditView);
stopwatchProvider.Remove(MeasuredOperation.OpenSelectProjectFromEditView);
var workspaces = await interactorFactory.GetAllWorkspaces().Execute();
shouldShowProjectCreationSuggestion = workspaces.Any(ws => ws.IsEligibleForProjectCreation());
allWorkspaces = workspaces.ToList();
UseGrouping = allWorkspaces.Count > 1;
dataSource.Projects
.GetAll()
.Select(projects => projects.Any())
.Subscribe(hasProjects => IsEmpty = !hasProjects);
infoSubject.AsObservable()
.StartWith(Text)
.Select(text => text.SplitToQueryWords())
.ObserveOn(schedulerProvider.BackgroundScheduler)
.SelectMany(query => interactorFactory.GetProjectsAutocompleteSuggestions(query).Execute())
.SubscribeOn(schedulerProvider.MainScheduler)
.Select(suggestions => suggestions.Cast <ProjectSuggestion>())
.Select(setSelectedProject)
.Subscribe(onSuggestions);
}
public override async Task Initialize()
{
var user = await dataSource.User.Current.FirstAsync();
var defaultWorkspace = await interactorFactory.GetDefaultWorkspace().Execute();
Email = user.Email;
Name = user.Fullname;
Version = userAgent.Version;
workspaceId = defaultWorkspace.Id;
WorkspaceName = defaultWorkspace.Name;
IsManualModeEnabled = userPreferences.IsManualModeEnabled;
BeginningOfWeek = user.BeginningOfWeek;
ImageUrl = user.ImageUrl;
var workspaces = await interactorFactory.GetAllWorkspaces().Execute();
foreach (var workspace in workspaces)
{
Workspaces.Add(new SelectableWorkspaceViewModel(workspace, workspace.Id == workspaceId));
}
dataSource.Preferences.Current
.Subscribe(updateFromPreferences);
}
public override async Task Initialize()
{
await base.Initialize();
startTimeEntryStopwatch = stopwatchProvider.Get(MeasuredOperation.OpenStartView);
stopwatchProvider.Remove(MeasuredOperation.OpenStartView);
defaultWorkspace = await interactorFactory.GetDefaultWorkspace()
.TrackException <InvalidOperationException, IThreadSafeWorkspace>("StartTimeEntryViewModel.Initialize")
.Execute();
canCreateProjectsInWorkspace =
await interactorFactory.GetAllWorkspaces().Execute().Select(allWorkspaces =>
allWorkspaces.Any(ws => ws.IsEligibleForProjectCreation()));
if (initialParameters != null)
{
var spans = new List <ISpan>();
spans.Add(new TextSpan(initialParameters.EntryDescription));
if (initialParameters.ProjectId != null)
{
try
{
var project = await interactorFactory.GetProjectById((long)initialParameters.ProjectId).Execute();
spans.Add(new ProjectSpan(project));
}
catch
{
// Intentionally left blank
}
}
if (initialParameters.TagIds != null)
{
try
{
var tags = initialParameters.TagIds.ToObservable()
.SelectMany <long, IThreadSafeTag>(tagId => interactorFactory.GetTagById(tagId).Execute())
.ToEnumerable();
spans.AddRange(tags.Select(tag => new TagSpan(tag)));
}
catch
{
// Intentionally left blank
}
}
textFieldInfo.Accept(textFieldInfo.Value.ReplaceSpans(spans.ToImmutableList()));
}
else
{
textFieldInfo.Accept(Autocomplete.TextFieldInfo.Empty(parameter?.WorkspaceId ?? defaultWorkspace.Id));
}
hasAnyTags = (await DataSource.Tags.GetAll()).Any();
hasAnyProjects = (await DataSource.Projects.GetAll()).Any();
}
public override async Task Initialize()
{
await base.Initialize();
var workspaces = await interactorFactory.GetAllWorkspaces().Execute();
allWorkspaces = workspaces.Select(w => new SelectableWorkspaceViewModel(w, w.Id == defaultWorkspaceId));
Suggestions.AddRange(allWorkspaces);
}
public override async Task Initialize()
{
await base.Initialize();
var workspaces = await interactorFactory.GetAllWorkspaces().Execute();
Workspaces = workspaces
.Where(w => w.IsEligibleForProjectCreation())
.Select(w => new SelectableWorkspaceViewModel(w, w.Id == currentWorkspaceId))
.ToList()
.AsReadOnly();
}
private async Task tryAgain()
{
var anyWorkspaceIsAvailable = await syncManager.ForceFullSync()
.Where(state => state == SyncState.Sleep)
.SelectMany(_ => interactorFactory.GetAllWorkspaces().Execute())
.Any(workspaces => workspaces.Any());
if (anyWorkspaceIsAvailable)
{
Close();
}
}
public override async Task Initialize(SelectWorkspaceParameters parameter)
{
await base.Initialize(parameter);
Title = parameter.Title;
currentWorkspaceId = parameter.CurrentWorkspaceId;
var workspaces = await interactorFactory.GetAllWorkspaces().Execute();
Workspaces = workspaces
.Where(w => w.IsEligibleForProjectCreation())
.Select(w => new SelectableWorkspaceViewModel(w, w.Id == currentWorkspaceId))
.ToImmutableList();
}
public override async Task Initialize(SelectProjectParameter parameter)
{
await base.Initialize(parameter);
creationEnabled = parameter.CreationEnabled;
taskId = parameter.TaskId;
projectId = parameter.ProjectId;
workspaceId = parameter.WorkspaceId;
var workspaces = await interactorFactory.GetAllWorkspaces().Execute();
projectCreationSuggestionsAreEnabled = workspaces.Any(ws => ws.IsEligibleForProjectCreation());
UseGrouping = workspaces.Count() > 1;
FilterText.Subscribe(async text =>
{
var suggestions = interactorFactory.GetProjectsAutocompleteSuggestions(text.SplitToQueryWords()).Execute().SelectMany(x => x).ToEnumerable()
.Cast <ProjectSuggestion>()
.Select(setSelectedProject);
var collectionSections = suggestions
.GroupBy(project => project.WorkspaceId)
.Select(grouping => grouping.OrderBy(projectSuggestion => projectSuggestion.ProjectName))
.OrderBy(grouping => grouping.First().WorkspaceName)
.Select(grouping => collectionSection(grouping, prependNoProject: string.IsNullOrEmpty(text)))
.ToList();
if (creationEnabled && shouldSuggestCreation(text))
{
var createEntitySuggestion = new CreateEntitySuggestion(Resources.CreateProject, text);
var section = new SectionModel <string, AutocompleteSuggestion>(null, new[] { createEntitySuggestion });
collectionSections.Insert(0, section);
}
if (collectionSections.None())
{
var workspace = await interactorFactory.GetWorkspaceById(workspaceId).Execute();
var noProjectSuggestion = ProjectSuggestion.NoProject(workspace.Id, workspace.Name);
collectionSections.Add(
new SectionModel <string, AutocompleteSuggestion>(null, new[] { noProjectSuggestion })
);
}
suggestionsSubject.OnNext(collectionSections.ToImmutableList());
});
}
public override async Task Initialize()
{
await base.Initialize();
var workspaces = await interactorFactory.GetAllWorkspaces().Execute();
allWorkspaces = workspaces.ToList();
UseGrouping = allWorkspaces.Count > 1;
dataSource.Projects
.GetAll()
.Select(projects => projects.Any())
.Subscribe(hasProjects => IsEmpty = !hasProjects);
infoSubject.AsObservable()
.StartWith(Text)
.SelectMany(text => dataSource.AutocompleteProvider.Query(new QueryInfo(text, AutocompleteSuggestionType.Projects)))
.Select(suggestions => suggestions.Cast <ProjectSuggestion>())
.Select(setSelectedProject)
.Subscribe(onSuggestions);
}
public override async Task Initialize()
{
navigationFromStartTimeEntryViewModelStopwatch = stopwatchProvider.Get(MeasuredOperation.OpenCreateProjectViewFromStartTimeEntryView);
stopwatchProvider.Remove(MeasuredOperation.OpenCreateProjectViewFromStartTimeEntryView);
var defaultWorkspace = await interactorFactory.GetDefaultWorkspace()
.TrackException <InvalidOperationException, IThreadSafeWorkspace>("EditProjectViewModel.Initialize")
.Execute();
var allWorkspaces = await interactorFactory.GetAllWorkspaces().Execute();
var workspace = defaultWorkspace.IsEligibleForProjectCreation()
? defaultWorkspace
: allWorkspaces.First(ws => ws.IsEligibleForProjectCreation());
areCustomColorsEnabled = await interactorFactory.AreCustomColorsEnabledForWorkspace(workspace.Id).Execute();
workspaceId = initialWorkspaceId = workspace.Id;
WorkspaceName = workspace.Name;
await setupNameAlreadyTakenError();
}
private IObservable <IThreadSafeWorkspace> pickWorkspace()
{
return(currentWorkspace.FirstAsync().SelectMany(workspaceFromViewModel));
IObservable <IThreadSafeWorkspace> workspaceFromViewModel(IThreadSafeWorkspace currentWorkspace)
=> interactorFactory.GetAllWorkspaces().Execute()
.SelectMany(allWorkspaces =>
{
var eligibleWorkspaces = allWorkspaces.Where(ws => ws.IsEligibleForProjectCreation()).ToList();
var selectWorkspaces = eligibleWorkspaces.Select(ws => new SelectOption <IThreadSafeWorkspace>(ws, ws.Name));
var selectedWorkspaceIndex = eligibleWorkspaces.IndexOf(ws => ws.Id == currentWorkspace.Id);
return(View.Select(Resources.Workspace, selectWorkspaces, selectedWorkspaceIndex));
})
.SelectMany(selectedWorkspace => workspaceFromId(selectedWorkspace.Id, currentWorkspace));
IObservable <IThreadSafeWorkspace> workspaceFromId(long selectedWorkspaceId, IThreadSafeWorkspace currentWorkspace)
=> selectedWorkspaceId == currentWorkspace.Id
? Observable.Empty <IThreadSafeWorkspace>()
: interactorFactory
.GetWorkspaceById(selectedWorkspaceId)
.Execute();
}
private async Task pickDefaultWorkspace()
{
var validWorkspaces = await interactorFactory.GetAllWorkspaces().Execute();
var workspaceSelections = validWorkspaces.Select(selectOptionFromWorkspace);
var selectedWorkspaceIndex = validWorkspaces
.IndexOf(ws => ws.Id == currentUser.DefaultWorkspaceId);
var newWorkspace = await View
.Select(Resources.DefaultWorkspace, workspaceSelections, selectedWorkspaceIndex);
if (currentUser.DefaultWorkspaceId == newWorkspace.Id)
{
return;
}
await interactorFactory.UpdateDefaultWorkspace(newWorkspace.Id).Execute();
syncManager.InitiatePushSync();
SelectOption <IThreadSafeWorkspace> selectOptionFromWorkspace(IThreadSafeWorkspace workspace)
=> new SelectOption <IThreadSafeWorkspace>(workspace, workspace.Name);
}
private async Task pickWorkspace()
{
var defaultWorkspaceId = SelectedWorkspace.Value?.Id ?? (await interactorFactory.GetDefaultWorkspace()
.TrackException <InvalidOperationException, IThreadSafeWorkspace>(
"SiriShortcutsSelectReportPeriodViewModel.PickWorkspace")
.Execute()).Id;
var allWorkspaces = await interactorFactory.GetAllWorkspaces().Execute();
var selectWorkspaces = allWorkspaces.Select(selectOptionFromWorkspace);
var selectedWorkspaceIndex = allWorkspaces.IndexOf(ws => ws.Id == defaultWorkspaceId);
var selectedWorkspace = await View.Select(Resources.Workspace, selectWorkspaces, selectedWorkspaceIndex);
if (SelectedWorkspace.Value?.Id == selectedWorkspace.Id)
{
return;
}
SelectedWorkspace.Accept(selectedWorkspace);
SelectOption <IThreadSafeWorkspace> selectOptionFromWorkspace(IThreadSafeWorkspace ws)
=> new SelectOption <IThreadSafeWorkspace>(ws, ws.Name);
}
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();
}
public IObservable <IEnumerable <IThreadSafeWorkspace> > GetUserWorkspaces() => interactorFactory.GetAllWorkspaces().Execute() .Select(ws => ws.ToList()) // <- This is to avoid Realm threading issues .ObserveOn(schedulerProvider.MainScheduler);
public SettingsViewModel(
ITogglDataSource dataSource,
ISyncManager syncManager,
IPlatformInfo platformInfo,
IDialogService dialogService,
IUserPreferences userPreferences,
IAnalyticsService analyticsService,
IUserAccessManager userAccessManager,
IInteractorFactory interactorFactory,
IOnboardingStorage onboardingStorage,
IMvxNavigationService navigationService,
IPrivateSharedStorageService privateSharedStorageService,
IIntentDonationService intentDonationService,
IStopwatchProvider stopwatchProvider,
IRxActionFactory rxActionFactory,
IPermissionsService permissionsService,
ISchedulerProvider schedulerProvider)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(syncManager, nameof(syncManager));
Ensure.Argument.IsNotNull(platformInfo, nameof(platformInfo));
Ensure.Argument.IsNotNull(dialogService, nameof(dialogService));
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(navigationService, nameof(navigationService));
Ensure.Argument.IsNotNull(userAccessManager, nameof(userAccessManager));
Ensure.Argument.IsNotNull(privateSharedStorageService, nameof(privateSharedStorageService));
Ensure.Argument.IsNotNull(intentDonationService, nameof(intentDonationService));
Ensure.Argument.IsNotNull(stopwatchProvider, nameof(stopwatchProvider));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(permissionsService, nameof(permissionsService));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
this.dataSource = dataSource;
this.syncManager = syncManager;
this.platformInfo = platformInfo;
this.dialogService = dialogService;
this.userPreferences = userPreferences;
this.rxActionFactory = rxActionFactory;
this.analyticsService = analyticsService;
this.interactorFactory = interactorFactory;
this.navigationService = navigationService;
this.userAccessManager = userAccessManager;
this.onboardingStorage = onboardingStorage;
this.stopwatchProvider = stopwatchProvider;
this.intentDonationService = intentDonationService;
this.privateSharedStorageService = privateSharedStorageService;
this.rxActionFactory = rxActionFactory;
this.schedulerProvider = schedulerProvider;
this.permissionsService = permissionsService;
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.ToString())
.AsDriver(schedulerProvider);
DateFormat =
dataSource.Preferences.Current
.Select(preferences => preferences.DateFormat.Localized)
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
DurationFormat =
dataSource.Preferences.Current
.Select(preferences => preferences.DurationFormat)
.Select(DurationFormatToString.Convert)
.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();
UserAvatar =
dataSource.User.Current
.Select(user => user.ImageUrl)
.DistinctUntilChanged()
.SelectMany(url => interactorFactory.GetUserAvatar(url).Execute())
.AsDriver(schedulerProvider)
.Where(avatar => avatar != null);
Workspaces =
dataSource.User.Current
.DistinctUntilChanged(user => user.DefaultWorkspaceId)
.SelectMany(user => interactorFactory
.GetAllWorkspaces()
.Execute()
.Select(selectableWorkspacesFromWorkspaces(user))
)
.AsDriver(schedulerProvider);
LoggingOut = loggingOutSubject.AsObservable()
.AsDriver(schedulerProvider);
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);
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);
SubmitFeedback = rxActionFactory.FromAsync(submitFeedback);
SelectDateFormat = rxActionFactory.FromAsync(selectDateFormat);
PickDefaultWorkspace = rxActionFactory.FromAsync(pickDefaultWorkspace);
SelectDurationFormat = rxActionFactory.FromAsync(selectDurationFormat);
SelectBeginningOfWeek = rxActionFactory.FromAsync(selectBeginningOfWeek);
ToggleTimeEntriesGrouping = rxActionFactory.FromAsync(toggleTimeEntriesGrouping);
SelectDefaultWorkspace = rxActionFactory.FromAsync <SelectableWorkspaceViewModel>(selectDefaultWorkspace);
Close = rxActionFactory.FromAsync(close);
}
public EditProjectViewModel(
ITogglDataSource dataSource,
IRxActionFactory rxActionFactory,
IInteractorFactory interactorFactory,
ISchedulerProvider schedulerProvider,
INavigationService navigationService)
: base(navigationService)
{
Ensure.Argument.IsNotNull(dataSource, nameof(dataSource));
Ensure.Argument.IsNotNull(rxActionFactory, nameof(rxActionFactory));
Ensure.Argument.IsNotNull(interactorFactory, nameof(interactorFactory));
Ensure.Argument.IsNotNull(schedulerProvider, nameof(schedulerProvider));
this.dataSource = dataSource;
this.interactorFactory = interactorFactory;
Name = new BehaviorRelay <string>("");
IsPrivate = new BehaviorRelay <bool>(true);
PickColor = rxActionFactory.FromObservable <Color>(pickColor);
PickClient = rxActionFactory.FromObservable <IThreadSafeClient>(pickClient);
PickWorkspace = rxActionFactory.FromObservable <IThreadSafeWorkspace>(pickWorkspace);
var initialWorkspaceObservable = interactorFactory
.GetDefaultWorkspace()
.TrackException <InvalidOperationException, IThreadSafeWorkspace>("EditProjectViewModel.Initialize")
.Execute()
.SelectMany(defaultWorkspaceOrWorkspaceEligibleForProjectCreation)
.Do(initialWorkspace => initialWorkspaceId = initialWorkspace.Id);
currentWorkspace = initialWorkspaceObservable
.Merge(PickWorkspace.Elements)
.ShareReplay(1);
currentClient = currentWorkspace
.SelectValue((IThreadSafeClient)null)
.Merge(PickClient.Elements)
.ShareReplay(1);
WorkspaceName = currentWorkspace
.Select(w => w.Name)
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
CanCreatePublicProjects = currentWorkspace
.Select(w => w.Admin)
.DoIf(isAdmin => !isAdmin, _ => IsPrivate.Accept(true))
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
var clientName = currentClient
.Select(client => client?.Name ?? "")
.DistinctUntilChanged();
ClientName = clientName
.AsDriver(schedulerProvider);
Color = PickColor.Elements
.StartWith(getRandomColor())
.Merge(currentWorkspace
.SelectMany(customColorIsEnabled)
.SelectMany(customColorsAreAvailable => customColorsAreAvailable
? Observable.Empty <Color>()
: Color.FirstAsync().Select(randomColorIfNotDefault)))
.DistinctUntilChanged()
.AsDriver(schedulerProvider);
var saveEnabledObservable = Name.Select(checkNameValidity);
var projectOrClientNameChanged = Observable
.Merge(clientName.SelectUnit(), Name.SelectUnit());
Save = rxActionFactory.FromObservable(done, saveEnabledObservable);
ToggleIsPrivate = rxActionFactory.FromAction(toggleIsPrivate);
Error = Save.Errors
.Select(e => e.Message)
.Merge(projectOrClientNameChanged.SelectValue(string.Empty))
.AsDriver(schedulerProvider);
IObservable <IThreadSafeWorkspace> defaultWorkspaceOrWorkspaceEligibleForProjectCreation(IThreadSafeWorkspace defaultWorkspace)
=> defaultWorkspace.IsEligibleForProjectCreation()
? Observable.Return(defaultWorkspace)
: interactorFactory.GetAllWorkspaces().Execute()
.Select(allWorkspaces => allWorkspaces.First(ws => ws.IsEligibleForProjectCreation()));
IObservable <bool> customColorIsEnabled(IThreadSafeWorkspace workspace)
=> interactorFactory
.AreCustomColorsEnabledForWorkspace(workspace.Id)
.Execute();
Color getRandomColor()
{
var randomColorIndex = random.Next(0, Helper.Colors.DefaultProjectColors.Length);
return(Helper.Colors.DefaultProjectColors[randomColorIndex]);
}
Color randomColorIfNotDefault(Color lastColor)
{
var hex = lastColor.ToHexString();
if (DefaultProjectColors.Any(defaultColor => defaultColor == hex))
{
return(lastColor);
}
return(getRandomColor());
}
bool checkNameValidity(string name)
=> !string.IsNullOrWhiteSpace(name) &&
name.LengthInBytes() <= Constants.MaxProjectNameLengthInBytes;
}
public override async Task Initialize(StartTimeEntryParameters parameter)
{
await base.Initialize(parameter);
this.parameter = parameter;
startTime = parameter.StartTime;
duration = parameter.Duration;
PlaceholderText = parameter.PlaceholderText;
if (!string.IsNullOrEmpty(parameter.EntryDescription))
{
initialParameters = parameter;
}
displayedTime.Accept(duration ?? TimeSpan.Zero);
timeService.CurrentDateTimeObservable
.Where(_ => isRunning)
.Subscribe(currentTime => displayedTime.Accept(currentTime - startTime))
.DisposedBy(disposeBag);
defaultWorkspace = await interactorFactory.GetDefaultWorkspace()
.TrackException <InvalidOperationException, IThreadSafeWorkspace>("StartTimeEntryViewModel.Initialize")
.Execute();
canCreateProjectsInWorkspace =
await interactorFactory.GetAllWorkspaces().Execute().Select(allWorkspaces =>
allWorkspaces.Any(ws => ws.IsEligibleForProjectCreation()));
if (initialParameters != null)
{
var spans = new List <ISpan>();
spans.Add(new TextSpan(initialParameters.EntryDescription));
if (initialParameters.ProjectId != null)
{
try
{
var project = await interactorFactory.GetProjectById((long)initialParameters.ProjectId).Execute();
spans.Add(new ProjectSpan(project));
}
catch
{
// Intentionally left blank
}
}
if (initialParameters.TagIds != null)
{
try
{
var tags = initialParameters.TagIds.ToObservable()
.SelectMany <long, IThreadSafeTag>(tagId => interactorFactory.GetTagById(tagId).Execute())
.ToEnumerable();
spans.AddRange(tags.Select(tag => new TagSpan(tag)));
}
catch
{
// Intentionally left blank
}
}
textFieldInfo.Accept(textFieldInfo.Value.ReplaceSpans(spans.ToImmutableList()));
}
else
{
textFieldInfo.Accept(Autocomplete.TextFieldInfo.Empty(parameter?.WorkspaceId ?? defaultWorkspace.Id));
}
hasAnyTags = (await DataSource.Tags.GetAll()).Any();
hasAnyProjects = (await DataSource.Projects.GetAll()).Any();
}
