public void TestChangeFilter1()
        {
            var model = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);
            var dataSourceViewModel = new Mock <IDataSourceViewModel>();

            dataSourceViewModel.SetupProperty(x => x.QuickFilterChain);

            var dataSource = CreateDataSource();

            var logFile = new InMemoryLogSource();

            dataSource.Setup(x => x.UnfilteredLogSource).Returns(logFile);
            var filteredLogFile = new InMemoryLogSource();

            dataSource.Setup(x => x.FilteredLogSource).Returns(filteredLogFile);
            dataSourceViewModel.Setup(x => x.DataSource).Returns(dataSource.Object);
            model.CurrentDataSource = dataSourceViewModel.Object;

            dataSourceViewModel.Object.QuickFilterChain.Should().BeNull("because no filter should be set right now");

            var filter = model.AddQuickFilter();

            filter.Value    = "Foobar";
            filter.IsActive = true;

            dataSourceViewModel.Object.QuickFilterChain.Should()
            .NotBeNull("because a filter chain should've been created for the 'Foobar' filter");
        }
        public void TestRenameMergedDataSource()
        {
            var model = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);

            var dataSourceViewModel = new Mock <IDataSourceViewModel>();
            var dataSource          = new Mock <IDataSource>();

            dataSource.Setup(x => x.FilteredLogSource).Returns(new Mock <ILogSource>().Object);
            dataSource.Setup(x => x.UnfilteredLogSource).Returns(new Mock <ILogSource>().Object);
            dataSourceViewModel.Setup(x => x.DataSource).Returns(dataSource.Object);
            dataSourceViewModel.Setup(x => x.DisplayName).Returns("Merged Data Source");
            dataSourceViewModel.Setup(x => x.DataSourceOrigin).Returns("Merged Data Source");

            model.CurrentDataSource = dataSourceViewModel.Object;
            model.WindowTitle.Should().Be(string.Format("{0} - Merged Data Source", Constants.MainWindowTitle));
            model.WindowTitleSuffix.Should().Be("Merged Data Source");

            dataSourceViewModel.Setup(x => x.DisplayName).Returns("My custom name");
            dataSourceViewModel.Raise(x => x.PropertyChanged += null, new PropertyChangedEventArgs("DisplayName"));
            dataSourceViewModel.Setup(x => x.DataSourceOrigin).Returns("My custom name");
            dataSourceViewModel.Raise(x => x.PropertyChanged += null, new PropertyChangedEventArgs("DataSourceOrigin"));

            model.WindowTitle.Should().Be(string.Format("{0} - My custom name", Constants.MainWindowTitle));
            model.WindowTitleSuffix.Should().Be("My custom name");
        }
        public void TestUpdate3()
        {
            var dataSource1 = new Mock <IFileDataSource>();

            dataSource1.Setup(x => x.FilteredLogSource).Returns(new Mock <ILogSource>().Object);
            dataSource1.Setup(x => x.UnfilteredLogSource).Returns(new Mock <ILogSource>().Object);
            var dataSource2 = new Mock <IFileDataSource>();

            dataSource2.Setup(x => x.FilteredLogSource).Returns(new Mock <ILogSource>().Object);
            dataSource2.Setup(x => x.UnfilteredLogSource).Returns(new Mock <ILogSource>().Object);

            _dataSources.Setup(x => x.Sources).Returns(new List <IDataSource> {
                dataSource1.Object, dataSource2.Object
            });
            var model = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);

            model.RecentFiles.Should().HaveCount(2);

            dataSource1.Setup(x => x.NoTimestampCount).Returns(42);
            dataSource2.Setup(x => x.NoTimestampCount).Returns(9001);

            model.Update();
            var viewModel1 = model.RecentFiles.First();

            viewModel1.NoTimestampCount.Should().Be(42);
            var viewModel2 = model.RecentFiles.Last();

            viewModel2.NoTimestampCount.Should().Be(9001);
        }
        public void TestGoToPreviousDataSource1()
        {
            var model = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);

            model.CurrentDataSource.Should().BeNull();
            new Action(() => model.GoToPreviousDataSource()).Should().NotThrow();
            model.CurrentDataSource.Should().BeNull();
        }
        public void TestShowQuickFilters()
        {
            var model = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);
            var quickFilterSidePanel = model.SidePanels.OfType <QuickFiltersSidePanelViewModel>().First();

            model.SelectedSidePanel.Should().NotBe(quickFilterSidePanel);

            model.ShowQuickFilters();
            model.SelectedSidePanel.Should().Be(quickFilterSidePanel);
        }
        public void TestSelectDataSourcePartOfMergedDataSource()
        {
            var mergedDataSource = new Mock <IMergedDataSource>();

            mergedDataSource.Setup(x => x.Id).Returns(DataSourceId.CreateNew());
            mergedDataSource.Setup(x => x.FilteredLogSource).Returns(new Mock <ILogSource>().Object);
            mergedDataSource.Setup(x => x.UnfilteredLogSource).Returns(new Mock <ILogSource>().Object);
            mergedDataSource.Setup(x => x.Settings).Returns(new DataSource());
            mergedDataSource.Setup(x => x.DisplayName).Returns("My custom merged data source");

            var dataSource1 = new Mock <IFileDataSource>();

            dataSource1.Setup(x => x.FilteredLogSource).Returns(new Mock <ILogSource>().Object);
            dataSource1.Setup(x => x.UnfilteredLogSource).Returns(new Mock <ILogSource>().Object);
            dataSource1.Setup(x => x.Id).Returns(DataSourceId.CreateNew());
            dataSource1.Setup(x => x.ParentId).Returns(mergedDataSource.Object.Id);
            dataSource1.Setup(x => x.Settings).Returns(new DataSource());
            dataSource1.Setup(x => x.FullFileName).Returns("log1.txt");
            dataSource1.SetupProperty(x => x.CharacterCode);

            var dataSource2 = new Mock <IFileDataSource>();

            dataSource2.Setup(x => x.FilteredLogSource).Returns(new Mock <ILogSource>().Object);
            dataSource2.Setup(x => x.UnfilteredLogSource).Returns(new Mock <ILogSource>().Object);
            dataSource2.Setup(x => x.Id).Returns(DataSourceId.CreateNew());
            dataSource2.Setup(x => x.Settings).Returns(new DataSource());
            dataSource2.Setup(x => x.FullFileName).Returns("log2.csv");
            dataSource2.SetupProperty(x => x.CharacterCode);

            _dataSources.Setup(x => x.Sources).Returns(new List <IDataSource> {
                mergedDataSource.Object, dataSource1.Object, dataSource2.Object
            });
            var model       = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);
            var dataSources = model.DataSources;

            var dataSource1ViewModel = dataSources.DataSources.First(x => x.DataSource == dataSource1.Object);

            model.CurrentDataSource = dataSource1ViewModel;
            model.WindowTitle.Should().Be($"{Constants.MainWindowTitle} - log1.txt");
            model.WindowTitleSuffix.Should().Be("My custom merged data source -> [A] log1.txt",
                                                "because the titlebar shall mention the parent's name, if available as well as the character code of the selected data source");

            var dataSource2ViewModel = dataSources.DataSources.First(x => x.DataSource == dataSource2.Object);

            model.CurrentDataSource = dataSource2ViewModel;
            model.WindowTitle.Should().Be($"{Constants.MainWindowTitle} - log2.csv");
            model.WindowTitleSuffix.Should().Be("log2.csv");

            var mergedViewModel = dataSources.DataSources.First(x => x.DataSource == mergedDataSource.Object);

            model.CurrentDataSource = mergedViewModel;
            model.WindowTitle.Should().Be($"{Constants.MainWindowTitle} - My custom merged data source");
            model.WindowTitleSuffix.Should().Be("My custom merged data source");
        }
        public void TestAddFolder()
        {
            var path   = Path.GetTempPath();
            var source = new Mock <IFolderDataSource>();

            source.Setup(x => x.OriginalSources).Returns(new IDataSource[0]);
            source.Setup(x => x.FilteredLogSource).Returns(new Mock <ILogSource>().Object);
            source.Setup(x => x.UnfilteredLogSource).Returns(new Mock <ILogSource>().Object);
            _dataSources.Setup(x => x.AddFolder(It.IsAny <string>())).Returns(source.Object);

            var model      = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);
            var dataSource = model.GetOrAddPath(path);

            dataSource.Should().BeOfType <FolderDataSourceViewModel>();
        }
        public void TestUpdate2()
        {
            var model = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);
            var dataSourceViewModel = new Mock <IDataSourceViewModel>();
            var dataSource          = new Mock <IDataSource>();
            var logFile             = new InMemoryLogSource();

            dataSource.Setup(x => x.UnfilteredLogSource).Returns(logFile);
            var filteredLogFile = new InMemoryLogSource();

            dataSource.Setup(x => x.FilteredLogSource).Returns(filteredLogFile);
            dataSourceViewModel.Setup(x => x.DataSource).Returns(dataSource.Object);
            model.CurrentDataSource = dataSourceViewModel.Object;

            logFile.AddEntry("", LevelFlags.All);
            logFile.SetValue(Properties.Size, Size.OneByte);
            model.Update();
            model.CurrentDataSourceLogView.NoEntriesExplanation.Should().Be("Nothing matches level filter");
        }
        public void TestUpdate1()
        {
            var model = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);

            new Action(() => model.Update()).Should().NotThrow();
        }
        public void TestConstruction()
        {
            var model = new LogViewMainPanelViewModel(_services, _actionCenter.Object, _dataSources.Object, _quickFilters.Object, _highlighters.Object, _settings.Object);

            model.Settings.Should().BeSameAs(_settings.Object.LogViewer);
        }
        public MainWindowViewModel(IApplicationSettings settings,
                                   DataSources dataSources,
                                   QuickFilters quickFilters,
                                   IActionCenter actionCenter,
                                   IAutoUpdater updater,
                                   ITaskScheduler taskScheduler,
                                   IAnalysisStorage analysisStorage,
                                   IDispatcher dispatcher,
                                   IPluginLoader pluginLoader)
        {
            if (dataSources == null)
            {
                throw new ArgumentNullException(nameof(dataSources));
            }
            if (quickFilters == null)
            {
                throw new ArgumentNullException(nameof(quickFilters));
            }
            if (updater == null)
            {
                throw new ArgumentNullException(nameof(updater));
            }
            if (dispatcher == null)
            {
                throw new ArgumentNullException(nameof(dispatcher));
            }

            _applicationSettings = settings;

            _plugins  = pluginLoader.Plugins;
            _settings = new SettingsMainPanelViewModel(settings);
            _actionCenterViewModel = new ActionCenterViewModel(dispatcher, actionCenter);

            _analysePanel = new AnalyseMainPanelViewModel(_applicationSettings, dataSources, dispatcher, taskScheduler, analysisStorage, pluginLoader);
            _analysePanel.PropertyChanged += AnalysePanelOnPropertyChanged;

            _logViewPanel = new LogViewMainPanelViewModel(actionCenter,
                                                          dataSources,
                                                          quickFilters,
                                                          _applicationSettings);
            _logViewPanel.PropertyChanged += LogViewPanelOnPropertyChanged;

            _timer = new DispatcherTimer
            {
                Interval = TimeSpan.FromMilliseconds(100)
            };
            _timer.Tick += TimerOnTick;
            _timer.Start();

            _autoUpdater                   = new AutoUpdateViewModel(updater, settings.AutoUpdate, dispatcher);
            _showLogCommand                = new DelegateCommand(ShowLog);
            _showGoToLineCommand           = new DelegateCommand2(ShowGoToLine);
            _showQuickNavigationCommand    = new DelegateCommand2(ShowQuickNavigation);
            _goToNextDataSourceCommand     = new DelegateCommand2(GoToNextDataSource);
            _goToPreviousDataSourceCommand = new DelegateCommand2(GoToPreviousDataSource);

            _analyseEntry = new AnalyseMainPanelEntry();
            _rawEntry     = new LogViewMainPanelEntry();
            _topEntries   = new IMainPanelEntry[]
            {
                _rawEntry,
                _analyseEntry
            };

            _settingsEntry = new SettingsMainPanelEntry();
            _pluginsEntry  = new PluginsMainPanelEntry();
            _aboutEntry    = new AboutMainPanelEntry();
            _bottomEntries = new[]
            {
                _settingsEntry,
                _pluginsEntry,
                _aboutEntry
            };

            var selectedTopEntry    = _topEntries.FirstOrDefault(x => x.Id == _applicationSettings.MainWindow.SelectedMainPanel);
            var selectedBottomEntry = _bottomEntries.FirstOrDefault(x => x.Id == _applicationSettings.MainWindow.SelectedMainPanel);

            if (selectedTopEntry != null)
            {
                SelectedTopEntry = selectedTopEntry;
            }
            else if (selectedBottomEntry != null)
            {
                SelectedBottomEntry = selectedBottomEntry;
            }
            else
            {
                SelectedTopEntry = _rawEntry;
            }
        }
        public MainWindowViewModel(IServiceContainer services,
                                   IApplicationSettings settings,
                                   DataSources dataSources,
                                   QuickFilters quickFilters,
                                   IActionCenter actionCenter,
                                   IAutoUpdater updater)
        {
            if (dataSources == null)
            {
                throw new ArgumentNullException(nameof(dataSources));
            }
            if (quickFilters == null)
            {
                throw new ArgumentNullException(nameof(quickFilters));
            }
            if (updater == null)
            {
                throw new ArgumentNullException(nameof(updater));
            }

            var services1           = services;
            var applicationSettings = settings;

            _plugins = new PluginsMainPanelViewModel(applicationSettings,
                                                     services1.Retrieve <IDispatcher>(),
                                                     services1.Retrieve <IPluginUpdater>(),
                                                     services1.Retrieve <IPluginLoader>().Plugins);
            _settings = new SettingsFlyoutViewModel(settings, services);
            _actionCenterViewModel = new ActionCenterViewModel(services.Retrieve <IDispatcher>(), actionCenter);

            _logViewPanel = new LogViewMainPanelViewModel(services,
                                                          actionCenter,
                                                          dataSources,
                                                          quickFilters,
                                                          services.Retrieve <IHighlighters>(),
                                                          applicationSettings);
            WindowTitle       = _logViewPanel.WindowTitle;
            WindowTitleSuffix = _logViewPanel.WindowTitleSuffix;

            ((NavigationService)services.Retrieve <INavigationService>()).LogViewer = _logViewPanel;

            _logViewPanel.PropertyChanged += LogViewPanelOnPropertyChanged;

            var timer = new DispatcherTimer
            {
                Interval = TimeSpan.FromMilliseconds(100)
            };

            timer.Tick += TimerOnTick;
            timer.Start();

            _autoUpdater = new AutoUpdateViewModel(updater, settings.AutoUpdate, services.Retrieve <IDispatcher>());

            var fileMenuViewModel = new FileMenuViewModel(new DelegateCommand2(AddDataSourceFromFile),
                                                          new DelegateCommand2(AddDataSourceFromFolder),
                                                          _logViewPanel.DataSources.RemoveCurrentDataSourceCommand,
                                                          _logViewPanel.DataSources.RemoveAllDataSourcesCommand,
                                                          new DelegateCommand2(ShowPlugins),
                                                          new DelegateCommand2(ShowSettings),
                                                          new DelegateCommand2(Exit));
            var editMenu = new EditMenuViewModel(new DelegateCommand2(ShowGoToLine),
                                                 new DelegateCommand2(ShowGoToDataSource),
                                                 new DelegateCommand2(GoToNextDataSource),
                                                 new DelegateCommand2(GoToPreviousDataSource),
                                                 _logViewPanel);
            var viewMenu = new ViewMenuViewModel();
            var helpMenu = new HelpMenuViewModel(new DelegateCommand2(ReportIssue),
                                                 new DelegateCommand2(SuggestFeature),
                                                 new DelegateCommand2(AskQuestion),
                                                 AutoUpdater.CheckForUpdatesCommand,
                                                 new DelegateCommand(ShowLog),
                                                 new DelegateCommand2(ShowAboutFlyout));

            _mainMenu = new MainMenu(fileMenuViewModel,
                                     editMenu,
                                     viewMenu,
                                     helpMenu);
            _mainMenu.CurrentDataSource = _logViewPanel.CurrentDataSource;
        }
        public MainWindowViewModel(IServiceContainer services,
                                   IApplicationSettings settings,
                                   DataSources dataSources,
                                   QuickFilters quickFilters,
                                   IActionCenter actionCenter,
                                   IAutoUpdater updater)
        {
            if (dataSources == null)
            {
                throw new ArgumentNullException(nameof(dataSources));
            }
            if (quickFilters == null)
            {
                throw new ArgumentNullException(nameof(quickFilters));
            }
            if (updater == null)
            {
                throw new ArgumentNullException(nameof(updater));
            }

            _services            = services;
            _applicationSettings = settings;

            _plugins  = services.Retrieve <IPluginLoader>().Plugins;
            _settings = new SettingsMainPanelViewModel(settings);
            _actionCenterViewModel = new ActionCenterViewModel(services.Retrieve <IDispatcher>(), actionCenter);

            _logViewPanel = new LogViewMainPanelViewModel(services,
                                                          actionCenter,
                                                          dataSources,
                                                          quickFilters,
                                                          services.Retrieve <IHighlighters>(),
                                                          _applicationSettings);
            ((NavigationService)services.Retrieve <INavigationService>()).LogViewer = _logViewPanel;

            _logViewPanel.PropertyChanged += LogViewPanelOnPropertyChanged;

            var timer = new DispatcherTimer
            {
                Interval = TimeSpan.FromMilliseconds(100)
            };

            timer.Tick += TimerOnTick;
            timer.Start();

            _autoUpdater                   = new AutoUpdateViewModel(updater, settings.AutoUpdate, services.Retrieve <IDispatcher>());
            _showLogCommand                = new DelegateCommand(ShowLog);
            _showGoToLineCommand           = new DelegateCommand2(ShowGoToLine);
            _showQuickNavigationCommand    = new DelegateCommand2(ShowQuickNavigation);
            _goToNextDataSourceCommand     = new DelegateCommand2(GoToNextDataSource);
            _goToPreviousDataSourceCommand = new DelegateCommand2(GoToPreviousDataSource);

            _rawEntry   = new LogViewMainPanelEntry();
            _topEntries = new IMainPanelEntry[]
            {
                _rawEntry
            };

            _settingsEntry = new SettingsMainPanelEntry();
            _pluginsEntry  = new PluginsMainPanelEntry();
            _aboutEntry    = new AboutMainPanelEntry();
            _bottomEntries = new[]
            {
                _settingsEntry,
                _pluginsEntry,
                _aboutEntry
            };

            var selectedTopEntry    = _topEntries.FirstOrDefault(x => x.Id == _applicationSettings.MainWindow.SelectedMainPanel);
            var selectedBottomEntry = _bottomEntries.FirstOrDefault(x => x.Id == _applicationSettings.MainWindow.SelectedMainPanel);

            if (selectedTopEntry != null)
            {
                SelectedTopEntry = selectedTopEntry;
            }
            else if (selectedBottomEntry != null)
            {
                SelectedBottomEntry = selectedBottomEntry;
            }
            else
            {
                SelectedTopEntry = _rawEntry;
            }

            _isLeftSidePanelVisible = settings.MainWindow.IsLeftSidePanelVisible;
            UpdateLeftSidePanelExpanderTooltip();
        }