private async void CommandHandler(object sender, ExecutedRoutedEventArgs args)
{
if (inCommand)
{
return;
}
try
{
inCommand = true;
if (args.Parameter is string query)
{
await SearchControlViewModel.SearchAsync(query).ConfigureAwait(false);
}
}
catch (Exception ex)
{
await MessageBoxService.ShowMessageBoxAsync(ex.Message).ConfigureAwait(false);
}
finally
{
inCommand = false;
}
}
public static Query GetSearchQuery(SearchControlViewModel ViewModel)
{
Query query = new Query();
// Get include paths
foreach (var p in ViewModel.SearchPaths.Where(x => x.IsInclude && x.IsValid))
{
ValidateSearchPath(p.PathValue);
query.AddFileSource(new DirectorySearchSource(p.PathValue, p.IsRecursive));
}
// Get exclude paths
foreach (var ex in ViewModel.SearchPaths.Where(x => x.IsExclude))
{
query.AddExcludePath(ex.PathValue);
}
// Get results file paths
foreach (var rf in ViewModel.SearchPaths.Where(x => x.IsResultsFile && x.IsValid))
{
query.AddFileSource(GetFileSource(rf.PathValue));
}
// Get search params
foreach (var f in ViewModel.SearchParams.Where(x => x.IsValid))
{
query.AddFilter(QueryFilterFactory.GetQueryFilter(f));
}
return(query);
}
/// <summary>
/// Converts a view model to yaml
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public static string ToYaml(SearchControlViewModel model)
{
var root = new YamlMappingNode();
root.Add("app", "filequery");
root.Add("version", Assembly.GetExecutingAssembly().GetName().Version.ToString());
var seq = new YamlSequenceNode();
foreach (var path in model.SearchPaths.Where(x => x.IsValid))
{
var map = new YamlMappingNode();
map.Add("type", path.PathType);
map.Add("value", path.PathValue);
seq.Add(map);
}
root.Add("paths", seq);
seq = new YamlSequenceNode();
foreach (var filter in model.SearchParams.Where(x => x.IsValid))
{
var map = new YamlMappingNode();
map.Add("type", filter.ParamType);
map.Add("value", filter.ParamValue);
map.Add("operator", filter.ParamOperator.Label);
seq.Add(map);
}
root.Add("filters", seq);
var yaml = new SerializerBuilder().Build().Serialize(root);
return(yaml);
}
protected override async Task Initialize()
{
try
{
EditButtonDisabled = false;
var navigationCommand = new NavigateToMediaCommand(_navigationService, _historyDataService);
SearchViewModel = new SearchControlViewModel(_documentInfoDataService, _searchContentDataService, _navigationService, navigationCommand);
var data = await _playlistsDataService.GetPlayListsData();
_allPlaylists = PlaylistViewModelBuilder.Create(data, navigationCommand, _dialogService);
PopulateRemoveCommand(_allPlaylists);
SetInternalMode(_allPlaylists, IsInternalModeEnable);
PlayLists = _allPlaylists;
EditButtonText = ReadOnlyModeStateText;
var personalLibrarydata = await _playlistsDataService.GetPersonalLibrarData();
PersonalLibraryViewModel = PlaylistViewModelBuilder.Create(personalLibrarydata, navigationCommand, _dialogService);
PersonalLibraryViewModel.IsInternalMode = IsInternalModeEnable;
NewPlaylistViewModel = new NewPlaylistViewModel(this.PlayLists, new NavigateToMediaCommand(_navigationService, _historyDataService), _dialogService, (vm) => _allPlaylists.Remove(vm));
EditButtonDisabled = true;
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Error);
}
}
/// <summary>
/// Initialize Visual Browser
/// Load all necessary data
/// </summary>
protected override async Task Initialize()
{
try
{
_currentMobileConfiguration = await _mobileConfigurationDataService.GetCurrentMobileConfiguration();
Buttons = VisualBrowserViewModelBuilder.CreateButtonsViewModel(_currentMobileConfiguration, ShowCategory).ToList();
TopCategories = VisualBrowserViewModelBuilder.CreateCategoriesViewModel(_currentMobileConfiguration.TopCategories, _navigateToMediaCommand, IsInternalModeEnable, SubCategorySelectionAction);
ControlBarViewModel = new ControlBarViewModel(_dialogService, SettingsDataService, _mobileAppConfigDataService, _currentMobileConfiguration, _userSessionService, _contactsService, _presentationDataService, _syncLogService);
ExpandedCategories = new ObservableCollection <CategoryViewModel>();
SearchViewModel = new SearchControlViewModel(_documentInfoDataService, _searchContentDataService, _navigationService, _navigateToMediaCommand);
if (_orientation.HasValue)
{
RefreshButtons(_orientation.Value);
GetAllCategoryContent().ForEach(c => c.HandleOrientation(_orientation.Value));
}
await LoadBackgroundImage();
if (_orientation.HasValue)
{
BackgroundImage = ResolveBackgroundImage(_orientation.Value);
}
}
catch (Exception e)
{
PlatformAdapter.SendToCustomLogger(e, LoggingLevel.Error);
// Report error here
}
}
public QueryProcessManager(SearchControlViewModel vm, Dispatcher dispatcher)
{
viewModel = vm;
this.dispatcher = dispatcher;
backgroundWorker = new BackgroundWorker()
{
WorkerSupportsCancellation = true
};
backgroundWorker.DoWork += BackgroundWorker_DoWork;
backgroundWorker.RunWorkerCompleted += BackgroundWorker_RunWorkerCompleted;
}
private static void ParsePaths(SearchControlViewModel model, YamlMappingNode mapping)
{
var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("paths")];
foreach (YamlMappingNode item in items)
{
model.SearchPaths.Add(new SearchPathItemViewModel
{
PathType = item.Children[new YamlScalarNode("type")].ToString(),
PathValue = item.Children[new YamlScalarNode("value")].ToString(),
});
}
}
/// <summary>
/// Load data
/// </summary>
protected sealed override async Task Initialize()
{
try
{
// Setup the Search model
SearchViewModel = new SearchControlViewModel(_documentInfoDataService, _searchContentDataService, _navigationService, NavigateToMediaCommand);
_spotLightItems = await _spotlightDataService.GetSpotlightData();
SetSource();
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Error);
}
}
/// <summary>
/// Converts a yaml stream to a view model
/// </summary>
/// <param name="reader"></param>
/// <returns></returns>
public static SearchControlViewModel FromYaml(TextReader reader)
{
var model = new SearchControlViewModel();
var yaml = new YamlStream();
yaml.Load(reader);
var mapping = (YamlMappingNode)yaml.Documents[0].RootNode;
Validate(mapping);
ParsePaths(model, mapping);
ParseFilters(model, mapping);
return(model);
}
protected override async Task Initialize()
{
try
{
// Setup the Search model
SearchViewModel = new SearchControlViewModel(_documentInfoDataService, _searchContentDataService, _navigationService, NavigateToMediaCommand);
var data = await _historyDataService.GetHistoryData();
_allHistoryItems = HistoryItemViewModelBuilder.Create(data);
OnInternalModeChanged(IsInternalModeEnable);
}
catch (Exception ex)
{
PlatformAdapter.SendToCustomLogger(ex, LoggingLevel.Error);
}
}
public SearchControl()
{
InitializeComponent();
// Init the query to the one stored in app settings
SearchControlViewModel query = null;
try
{
query = AppSettingsFacade.Instance.SearchQuery;
}
catch (Exception ex)
{
AppSettingsFacade.Instance.SearchQuery = null;
MessageBox.Show("Error loading search query from app settings: " + ex.Message);
}
DataContext = query ?? new SearchControlViewModel();
}
private static void ParseFilters(SearchControlViewModel model, YamlMappingNode mapping)
{
var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("filters")];
foreach (YamlMappingNode item in items)
{
var filterType = item.Children[new YamlScalarNode("type")].ToString();
var ops = FilterOperatorUtil.GetOperatorsForType(filterType);
var opName = item.Children[new YamlScalarNode("operator")].ToString();
var op = ops.FirstOrDefault(x => x.Label == opName);
model.SearchParams.Add(new SearchParamItemViewModel
{
ParamType = filterType,
ParamOperator = op,
ParamValue = item.Children[new YamlScalarNode("value")].ToString()
});
}
}
private async ValueTask CommandHandlerAsync()
{
try
{
if (inCommand)
{
return;
}
inCommand = true;
await SearchControlViewModel.MentionsAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
await MessageBoxService.ShowMessageBoxAsync(ex.Message).ConfigureAwait(false);
}
finally
{
inCommand = false;
}
}
protected override async Task Initialize()
{
try
{
var navigationCommand = new NavigateToMediaCommand(_navigationService, _historyDataService);
var data = await _browserDataService.GetBrowserData();
MainCategory = MenuBrowserCategoryContentViewModelBuilder.Create(data, navigationCommand, IsInternalModeEnable, SelectCategory);
Categories = new ObservableCollection <CategoryItem> {
MainCategory
};
// Setup the Search model
SearchViewModel = new SearchControlViewModel(_documentInfoDataService, _searchContentDataService, _navigationService, navigationCommand);
}
catch (Exception ex)
{
// Report error here
}
}
private async void CommandHandler(object sender, ExecutedRoutedEventArgs e)
{
try
{
if (inCommand)
{
return;
}
inCommand = true;
await SearchControlViewModel.MentionsAsync().ConfigureAwait(false);
}
catch (Exception ex)
{
await MessageBoxService.ShowMessageBoxAsync(ex.Message).ConfigureAwait(false);
}
finally
{
inCommand = false;
}
}
public void CanSerializeToYaml()
{
var vm = new SearchControlViewModel();
vm.SearchParams.Add(new SearchParamItemViewModel {
ParamType = "Extension", ParamValue = "txt", ParamOperator = FilterOperatorUtil.GetOperatorItem("Extension", FilterOperator.Equal)
});
vm.SearchParams.Add(new SearchParamItemViewModel {
ParamType = "Contents", ParamValue = "test contents", ParamOperator = FilterOperatorUtil.GetOperatorItem("Contents", FilterOperator.NotEqual)
});
vm.SearchParams.Add(new SearchParamItemViewModel {
ParamType = "Modified Date", ParamValue = "9/8/2017", ParamOperator = FilterOperatorUtil.GetOperatorItem("Modified Date", FilterOperator.LessThan)
});
vm.SearchParams.Add(new SearchParamItemViewModel {
ParamType = "Name", ParamValue = "a, b, c", ParamOperator = FilterOperatorUtil.GetOperatorItem("Name", FilterOperator.In)
});
vm.SearchParams.Add(new SearchParamItemViewModel {
ParamType = "Read Only", ParamValue = "", ParamOperator = FilterOperatorUtil.GetOperatorItem("Read Only", FilterOperator.Equal)
});
vm.SearchParams.Add(new SearchParamItemViewModel {
ParamType = "Size", ParamValue = "1KB", ParamOperator = FilterOperatorUtil.GetOperatorItem("Size", FilterOperator.GreaterThanEqual)
});
vm.SearchPaths.Add(new SearchPathItemViewModel {
PathType = "Include-Recursive", PathValue = @"c:\recurse"
});
vm.SearchPaths.Add(new SearchPathItemViewModel {
PathType = "Include-NoRecurse", PathValue = @"c:\norecurse"
});
vm.SearchPaths.Add(new SearchPathItemViewModel {
PathType = "Exclude", PathValue = @"c:\exclude"
});
var yaml = SearchQuerySerializer.ToYaml(vm);
Assert.AreEqual(filterYaml, yaml);
}
public SearchCommand(SearchControlViewModel searchControlViewModel, IMessageBoxService messageBoxService)
{
SearchControlViewModel = searchControlViewModel;
MessageBoxService = messageBoxService;
}
