public void Generic_Constructor_WithCanExecuteParameter_CanExecuteIsNotNull()
{
ObservableVariable <bool> canExecute = new ObservableVariable <bool>();
ObservableCommand <int> command = new ObservableCommand <int>(canExecute);
Assert.IsNotNull(command.CanExecute);
}
public MainViewModel()
{
this.Items = new ObservableCollection<TaskViewModel>();
this.Completed = new ObservableCollection<TaskViewModel>();
logOut = new ObservableCommand<Object>();
auth.IsAuthenticated.Subscribe(logOut);
logOut.Subscribe(v => auth.logOut());
}
public void Generic_Constructor_WithCallbackParameter_OnRequestExecuteEventIsNotNull()
{
int callbackCount = 0;
ObservableCommand <int> command = new ObservableCommand <int>((value) => callbackCount++);
command.Execute(14);
Assert.IsTrue(callbackCount == 1);
}
public void Constructor_WithCallbackParameter_OnRequestExecuteEventIsNotNull()
{
int callbackCount = 0;
ObservableCommand command = new ObservableCommand(() => callbackCount++);
command.Execute();
Assert.IsTrue(callbackCount == 1);
}
public ChooseTaskViewModel(ITfsApi tfs)
{
_tfs = tfs;
SpecialCommand = new ObservableCommand(CreateTask);
Searcher = new WorkItemSearcher(_tfs, WorkItemTypes.Task)
{
Help = Resources.AS_ChooseTask
};
}
public ShellViewModel()
{
_semanticLoggingServiceInstalled = new ObservableProperty<bool>(false, this, () => SemanticLoggingServiceInstalled);
_installSemanticLoggingService = new ObservableCommand();
_behaviors = new CompositeDisposable(
InstallSemanticLoggingServiceCommandShouldBeEnabledWhenSemanticLoggingServiceIsNotInstalled(),
SemanticLoggingServiceShouldBeInstalledWhenInstallSemanticLoggingServiceCommandExecuted()
);
}
public void Execute_WhenCanExecute_RaiseEvent()
{
ObservableCommand command = new ObservableCommand();
int callbackCount = 0;
command.ExecuteRequested += () => callbackCount++;
command.Execute();
Assert.IsTrue(callbackCount == 1);
}
public SettingsViewModel(string currentConnection, ITfsApi api)
{
_api = api;
ConnectCommand = new ObservableCommand(OnConnect);
SubmitCommand = new ObservableCommand(OnSave, OnCanSave);
ChooseLogFileCommand = new ObservableCommand(OnChooseFile);
Init(currentConnection);
}
public void Generic_Execute_WhenCanExecute_RaiseEvent()
{
ObservableCommand <int> command = new ObservableCommand <int>();
int callbackCount = 0;
command.ExecuteRequested += (int value) => callbackCount++;
command.Execute(14);
Assert.IsTrue(callbackCount == 1);
}
public MainViewModel()
{
_safeExecutor = new SafeExecutor();
ShowMonthlyCommand = new ObservableCommand(ShowMonthly);
UpdateCommand = ObservableCommand.FromAsyncHandler(Update);
SettingsCommand = new ObservableCommand(ShowSettings);
WriteOffHoursCommand = new ObservableCommand(OnWriteHours);
Init();
}
public AllArtistsViewModel(IEventAggregator eventAggregator)
{
_eventAggregator = eventAggregator;
_artists = new ObservableCollection<Music.IArtist>();
_selectArtistCommand = new ObservableCommand();
_behaviours = new CompositeDisposable(
EnsureArtistsAreRetrievedWhenServerIsConnected(),
EnsureArtistSelectedMessagePublishedWhenSelectArtistCommandExecuted()
);
}
public void Generic_Execute_WhenCanExecute_ParameterIsReceived()
{
ObservableVariable <bool> canExecute = new ObservableVariable <bool>(true);
ObservableCommand <int> command = new ObservableCommand <int>(canExecute);
int mirrorVariable = -1;
command.ExecuteRequested += (int value) => mirrorVariable = value;
command.Execute(14);
Assert.IsTrue(mirrorVariable == 14);
}
public MainWindowViewModel(Service.IBridge bootstrapper)
{
_bridge = bootstrapper;
_registerCommand = new ObservableCommand();
_actionCommand = new ObservableCommand();
_behaviors = new CompositeDisposable(
EnsureRegisterCommandRegistersEntity(),
EnsureActionCommandPerformsAction()
);
}
public AllArtistsViewModel(IEventAggregator eventAggregator)
{
_eventAggregator = eventAggregator;
_artists = new ObservableCollection <Music.IArtist>();
_selectArtistCommand = new ObservableCommand();
_behaviours = new CompositeDisposable(
EnsureArtistsAreRetrievedWhenServerIsConnected(),
EnsureArtistSelectedMessagePublishedWhenSelectArtistCommandExecuted()
);
}
public MainWindowViewModel(Service.IBridge bootstrapper)
{
_bridge = bootstrapper;
_registerCommand = new ObservableCommand();
_actionCommand = new ObservableCommand();
_behaviors = new CompositeDisposable(
EnsureRegisterCommandRegistersEntity(),
EnsureActionCommandPerformsAction()
);
}
public ShellViewModel()
{
_username = new ObservableProperty <string>(this, () => Username);
_password = new ObservableProperty <string>(this, () => Password);
_logInCommand = new ObservableCommand();
_cancelCommand = new ObservableCommand();
_username.CombineLatest(_password, (username, password) => !string.IsNullOrWhiteSpace(username) && !string.IsNullOrWhiteSpace(password)).Subscribe(_logInCommand);
_logInCommand.Subscribe(ExecuteLogIn);
_cancelCommand.Subscribe(ExecuteCancel);
}
public void Generic_Execute_WhenCanNotExecute_DoNotRaiseEvent()
{
ObservableVariable <bool> canExecute = new ObservableVariable <bool>(true);
ObservableCommand <int> command = new ObservableCommand <int>(canExecute);
canExecute.Value = false;
int callbackCount = 0;
command.ExecuteRequested += (int value) => callbackCount++;
command.Execute(14);
Assert.IsTrue(callbackCount == 0);
}
public void Execute_WhenCanNotExecute_DoNotRaiseEvent()
{
ObservableVariable <bool> canExecute = new ObservableVariable <bool>();
ObservableCommand command = new ObservableCommand(canExecute);
canExecute.Value = false;
int callbackCount = 0;
command.ExecuteRequested += () => callbackCount++;
command.Execute();
Assert.IsTrue(callbackCount == 0);
}
public NewResponsesBaloonViewModel(IEnumerable <WorkItem> responses,
IEnumerable <WorkItem> reviews,
ITfsApi api,
string title = null)
: base(responses, title ?? Resources.AS_CodeReviewRequested)
{
_reviews = reviews.ToList();
_api = api;
_time = TimeSpan.FromDays(Settings.Settings.Read().OldReviewDay);
CloseReviewes = ObservableCommand.FromAsyncHandler(OnCloseGoodLooking, OnCanCloseGoodLooking).ExecuteOnce();
CloseOldReviewes = ObservableCommand.FromAsyncHandler(OnCloseOld, OnCanCloseOld).ExecuteOnce();
}
public CreateTaskViewModel(ITfsApi tfs)
{
_tfs = tfs;
// Ищем для привязки только указанные типы
Searcher = new WorkItemSearcher(tfs,
WorkItemTypes.Pbi,
WorkItemTypes.Bug,
WorkItemTypes.Improvement,
WorkItemTypes.Incident)
{
Help = Resources.AS_ChooseParentItem
};
SubmitCommand = new ObservableCommand(CreateTask, OnCanCreateTask);
}
public ChannelsViewModel(
ICategoriesRepository categoriesRepository,
ITranslationsService translationsService,
INavigationService navigationService,
IFactoryService factoryService,
IDialogService dialogService)
{
(IsEmpty, IsLoading) = (false, true);
Items = new ObservableCollection <ChannelCategoryViewModel>();
OpenSearch = new ObservableCommand(navigationService.Navigate <SearchViewModel>);
AddCategory = new ObservableCommand(async() =>
{
var name = await dialogService.ShowDialogForResults(
translationsService.Resolve("EnterNameOfNewCategory"),
translationsService.Resolve("EnterNameOfNewCategoryTitle"));
if (string.IsNullOrWhiteSpace(name))
{
return;
}
var category = new Category {
Title = name
};
await categoriesRepository.InsertAsync(category);
Items.Add(factoryService.CreateInstance <
ChannelCategoryViewModel>(category, this));
});
Load = new ObservableCommand(async() =>
{
IsLoading.Value = true;
var categories = await categoriesRepository.GetAllAsync();
Items.Clear();
foreach (var category in categories)
{
Items.Add(factoryService.CreateInstance <
ChannelCategoryViewModel>(category, this));
}
IsEmpty.Value = Items.Count == 0;
IsLoading.Value = false;
// Subscribe on collection changed to perform items rearranging.
Items.CollectionChanged += async(s, a) =>
{
IsEmpty.Value = Items.Count == 0;
var items = Items.Select(i => i.Category.Value);
await categoriesRepository.RearrangeAsync(items);
};
});
}
public FirstConnectionViewModel()
{
using (var settings = Settings.Settings.Read())
{
RememberedConnections = settings.Connections?.ToList() ?? new List <string>();
if (!RememberedConnections.IsNullOrEmpty())
{
Text = RememberedConnections.First();
}
}
CheckConnectionCommand = ObservableCommand.FromAsyncHandler(Connect, CanConnect);
SubmitCommand = new ObservableCommand(() => { },
() => Connection == ConnectionType.Success);
}
public MenuViewModel(
ITranslationsService translationsService,
INavigationService navigationService,
IPlatformService platformService,
ISettingsService settingsService)
{
SelectedIndex = 0;
Items = new ObservableCollection <Tuple <string, object, ObservableCommand, Type> >();
Load = new ObservableCommand(async() =>
{
await navigationService.Navigate <FeedViewModel>();
var theme = await settingsService.GetAsync <string>("Theme");
await platformService.RegisterTheme(theme);
var freq = await settingsService.GetAsync <int>("NotifyPeriod");
await platformService.RegisterBackgroundTask(freq);
await settingsService.SetAsync("LastFetched", DateTime.Now);
});
CreateItem <FeedViewModel>("FeedViewMenuItem");
CreateItem <FaveViewModel>("FaveViewMenuItem");
CreateItem <ChannelsViewModel>("SourcesViewMenuItem");
CreateItem <SearchViewModel>("SearchViewMenuItem");
CreateItem <SettingsViewModel>("SettingsViewMenuItem");
navigationService.Navigated += (sender, args) =>
{
var first = Items.FirstOrDefault(x => x.Item4 == args);
if (first == null)
{
return;
}
SelectedIndex.Value = Items.IndexOf(first);
};
void CreateItem <T>(string key) where T : class
{
var type = typeof(T);
var command = new ObservableCommand(navigationService.Navigate <T>);
var translation = translationsService.Resolve(key);
var icon = navigationService.Icons[type];
var tuple = (translation, icon, command, type).ToTuple();
Items.Add(tuple);
}
}
public SearchViewModel(ILog log, IDispatcherSchedulerProvider scheduler, IStandardDialog standardDialog, ISearchService service,
ReactiveSingleSelectCollection <Entity> entityCollection,
ReactiveSingleSelectCollection <Dimension> dimensionCollection,
BindableCollection <string> logOutputCollection)
: base(log, scheduler, standardDialog)
{
_service = service;
Disposables.Add(service);
Entity = entityCollection;
Dimension = dimensionCollection;
LogOutput = logOutputCollection;
EntityEnterCommand = new ObservableCommand();
DimensionEnterCommand = new ObservableCommand();
EntitySetup();
DimensionSetup();
}
public LogInPageViewModel(IAuthenticationService authenticationService)
{
_authenticationService = authenticationService;
_username = new ObservableProperty<string>(this, () => Username);
_password = new ObservableProperty<string>(this, () => Password);
_error = new ObservableProperty<string>(this, () => Error);
_logInCommand = new ObservableCommand();
_cancelCommand = new ObservableCommand();
_logInResponse = new Subject<AuthenticationResponse>();
_behaviors = new CompositeDisposable(
WhenTheUserHasEnteredBothUsernameAndPasswordThenEnableLogInButton(),
WhenTheUserClicksTheLogInButtonAttemptToLogIn(),
WhenASuccessfulLogInAttemptIsMadeCloseTheDialog(),
WhenAnUnsuccessfulLogInAttemptIsMadeDisplayTheError(),
WhenTheUserClicksTheCancelButtonCloseTheDialog()
);
}
private void CreateSaveToolBar(IToolBarService toolBarService)
{
var saveCommand = new ObservableCommand(Model.IsValid);
saveCommand.Executed
.ObserveOn(Scheduler.Task.RX)
.SelectMany(_ => _service.SaveAsync()
.ToObservable()
.TakeUntil(BusyViewModel.BusyLatch))
.TakeUntil(ClosingStrategy.Closed)
.Subscribe(_ => { });
var saveToolBarItem = toolBarService.CreateToolBarButtonItem();
saveToolBarItem.DisplayName = "Save";
saveToolBarItem.ImageName = IconNames.SAVE;
saveToolBarItem.Command = saveCommand;
ToolBarItems.Add(saveToolBarItem);
this.SyncToolBarItemWithViewModelActivationState(saveToolBarItem).AddDisposable(Disposables);
}
public ShellViewModel(ViewModels.IAllArtistsViewModel allArtistsViewModel, ViewModels.IAlbumsForArtistViewModel albumsForArtistViewModel, IEventAggregator eventAggregator)
{
Items.AddRange(new IScreen[] { allArtistsViewModel, albumsForArtistViewModel });
AllArtistsViewModel = allArtistsViewModel;
AlbumsForArtistViewModel = albumsForArtistViewModel;
_eventAggregator = eventAggregator;
_host = new ObservableProperty <string>("winplex", this, () => Host);
_port = new ObservableProperty <ushort>(32400, this, () => Port);
_connectCommand = new ObservableCommand();
_server = new Subject <IServer>();
ActivateItem(allArtistsViewModel);
_behaviors = new CompositeDisposable(
EnsureConnectCommandConnectsToServer(),
EnsureServerConnectionIsPublished(),
EnsureAlbumsForArtistsDisplayedWhenArtistSelected()
);
}
private List <ObservableCommand> CompileAndLinkTextSection()
{
var commandList = new List <ObservableCommand>();
using (var memoryStream = new MemoryStream())
{
using (var binaryWriter = new BinaryWriter(memoryStream))
{
var offset = 0;
foreach (var t in CommandList)
{
var observableCommand = new ObservableCommand
{
Status = EntryPoint == offset ? EPipeline.Fetch : EPipeline.None,
Address = (uint)offset,
Breakpoint = false,
Commandline = t
};
foreach (var label in CommandTable.Where(label => label.Value == offset))
{
observableCommand.Label = label.Key;
}
commandList.Add(observableCommand);
var command = Parser.ParseLine(t);
command.Link(CommandTable, DataTable, offset);
offset += command.GetCommandSize(_align);
binaryWriter.Write(GenerateBytes(command, _align));
}
Ram.WriteTextSection(memoryStream.ToArray());
}
}
return(commandList);
}
public SearchViewModel(
IFactoryService factoryService,
ISearchService searchService)
{
SearchQuery = string.Empty;
(IsGreeting, IsEmpty, IsLoading) = (true, false, false);
Items = new ObservableCollection <SearchItemViewModel>();
Fetch = new ObservableCommand(async() =>
{
IsLoading.Value = true;
var query = SearchQuery.Value;
var searchResults = await searchService.SearchAsync(query);
IsGreeting.Value = false;
Items.Clear();
foreach (var feedlyItem in searchResults.Results)
{
Items.Add(factoryService.CreateInstance <
SearchItemViewModel>(feedlyItem));
}
IsEmpty.Value = Items.Count == 0;
IsLoading.Value = false;
});
}
public SearchItemViewModel(
ICategoriesRepository categoriesRepository,
IPlatformService platformService,
IDialogService dialogService,
FeedlyItem feedlyItem)
{
Url = feedlyItem.Website;
Title = feedlyItem.Title;
ImageUri = feedlyItem.IconUrl;
Description = feedlyItem.Description;
FeedUrl = feedlyItem.FeedId?.Substring(5);
CopyLink = new ObservableCommand(() => platformService.CopyTextToClipboard(feedlyItem.Website));
OpenInEdge = new ObservableCommand(async() =>
{
if (Uri.IsWellFormedUriString(feedlyItem.Website, UriKind.Absolute))
{
await platformService.LaunchUri(new Uri(feedlyItem.Website));
}
});
AddToSources = new ObservableCommand(async() =>
{
if (!Uri.IsWellFormedUriString(FeedUrl.Value, UriKind.Absolute))
{
return;
}
var categories = await categoriesRepository.GetAllAsync();
var response = await dialogService.ShowDialogForSelection(categories);
if (response is Category category)
{
var source = new Channel {
Notify = true, Uri = FeedUrl.Value
};
await categoriesRepository.InsertChannelAsync(category, source);
}
});
}
public FaveViewModel(
IFavoritesRepository favoritesReposirory,
IFactoryService factoryService)
{
(IsEmpty, IsLoading) = (false, true);
var longDatePattern = CultureInfo.CurrentCulture.DateTimeFormat.LongDatePattern;
Items = new ObservableCollection <ObservableGrouping <string, ArticleViewModel> >();
Load = new ObservableCommand(async() =>
{
IsLoading.Value = true;
var articles = await favoritesReposirory.GetAllAsync();
Items.Clear();
var groupings = articles
.Select(i => factoryService.CreateInstance <ArticleViewModel>(i))
.OrderByDescending(i => i.PublishedDate.Value)
.GroupBy(i => i.PublishedDate.Value.ToString(longDatePattern))
.Select(i => new ObservableGrouping <string, ArticleViewModel>(i))
.ToList();
groupings.ForEach(Items.Add);
foreach (var grouping in groupings)
{
foreach (var viewModel in grouping)
{
viewModel.IsFavorite.PropertyChanged += (o, args) => RemoveOrRestore(viewModel);
}
}
IsEmpty.Value = Items.Count == 0;
IsLoading.Value = false;
});
OrderByDate = new ObservableCommand(() =>
{
IsLoading.Value = true;
var groupings = Items
.SelectMany(i => i)
.OrderByDescending(i => i.PublishedDate.Value)
.GroupBy(i => i.PublishedDate.Value.ToString(longDatePattern))
.Select(i => new ObservableGrouping <string, ArticleViewModel>(i))
.ToList();
Items.Clear();
groupings.ForEach(Items.Add);
IsLoading.Value = false;
});
OrderByFeed = new ObservableCommand(() =>
{
IsLoading.Value = true;
var groupings = Items
.SelectMany(i => i)
.OrderBy(i => i.Feed.Value)
.GroupBy(i => i.Feed.Value.ToString())
.Select(i => new ObservableGrouping <string, ArticleViewModel>(i))
.ToList();
Items.Clear();
groupings.ForEach(Items.Add);
IsLoading.Value = false;
});
void RemoveOrRestore(ArticleViewModel viewModel)
{
if (!viewModel.IsFavorite.Value)
{
var related = Items.First(i => i.Contains(viewModel));
related.Remove(viewModel);
if (related.Count == 0)
{
Items.Remove(related);
}
}
else
{
const string restored = "*Restored";
var existing = Items.FirstOrDefault(i => i.Key == restored);
if (existing == null)
{
Items.Add(new ObservableGrouping <
string, ArticleViewModel>(restored, new[] { viewModel }));
}
else
{
existing.Add(viewModel);
}
}
}
}
public AvailableJob(Job job)
{
this.Job = job;
var cmd =new ObservableCommand();
cmd.Subscribe(_ => OnToggleSelection());
this.ToggleSelectionCommand = cmd;
}
public ArticleViewModel(
ICategoriesRepository categoriesRepository,
ITranslationsService translationsService,
INavigationService navigationService,
IFavoritesService favoritesService,
ISettingsService settingsService,
IPlatformService platformService,
IDialogService dialogService,
Article article)
{
Title = article.Title;
Feed = article.FeedTitle;
Content = article.Content;
PublishedDate = article.PublishedDate;
IsFavorite = article.Fave;
IsRead = article.Read;
Open = new ObservableCommand(() => navigationService.Navigate <ArticleViewModel>(this));
Image = new ObservableProperty <string>(async() =>
{
var shouldLoadImages = await settingsService.GetAsync <bool>("LoadImages");
return(shouldLoadImages ? article.ImageUri : null);
});
Share = new ObservableCommand(() =>
{
var shareMessage = string.Concat(
article.Title, Environment.NewLine,
article.Uri, Environment.NewLine,
"via myFeed for Windows Universal");
return(platformService.Share(shareMessage));
});
CopyLink = new ObservableCommand(async() =>
{
await platformService.CopyTextToClipboard(article.Uri);
await dialogService.ShowDialog(
translationsService.Resolve("CopyLinkSuccess"),
translationsService.Resolve("SettingsNotification"));
});
LaunchUri = new ObservableCommand(async() =>
{
if (Uri.IsWellFormedUriString(article.Uri, UriKind.Absolute))
{
await platformService.LaunchUri(new Uri(article.Uri));
}
});
MarkRead = new ObservableCommand(async() =>
{
IsRead.Value = article.Read = !IsRead.Value;
await categoriesRepository.UpdateArticleAsync(article);
});
MarkFavorite = new ObservableCommand(async() =>
{
IsFavorite.Value = !IsFavorite.Value;
if (IsFavorite.Value)
{
await favoritesService.Insert(article);
}
else
{
await favoritesService.Remove(article);
}
});
}
public void Generic_Constructor_WithNoParameters_CanExecuteValueIsTrue()
{
ObservableCommand <int> command = new ObservableCommand <int>();
Assert.IsTrue(command.CanExecute.Value);
}
public void Constructor_WithNoParameters_CanExecuteIsNotNull()
{
ObservableCommand command = new ObservableCommand();
Assert.IsNotNull(command.CanExecute);
}
public void Generic_Constructor_WithNoParameters_CanExecuteIsNotNull()
{
ObservableCommand <bool> command = new ObservableCommand <bool>();
Assert.IsNotNull(command.CanExecute);
}
