private void RefreshLogFilesSourceCacheAsync(LogView oldLogView, LogView newLogView)
{
Task.Run(() =>
{
var logFilesToRefresh = new List <LogFile>();
if (oldLogView != null)
{
foreach (var identifier in oldLogView.AllLogFilePathsAndDatabaseNames)
{
var logFile = LogFilesSourceCache.Lookup(identifier);
if (logFile.HasValue)
{
logFilesToRefresh.Add(logFile.Value);
}
}
}
if (newLogView != null)
{
foreach (var identifier in newLogView.AllLogFilePathsAndDatabaseNames)
{
var logFile = LogFilesSourceCache.Lookup(identifier);
if (logFile.HasValue)
{
logFilesToRefresh.Add(logFile.Value);
}
}
}
LogFilesSourceCache.Refresh(logFilesToRefresh);
RaisePropertyChangedEvent("LogFiles");
});
}
public void OpenLogFilePath(string logFilePath)
{
var newLogFile = new LogFile(logFilePath);
SettingsService.AddOrUpdateLogFile(newLogFile, true);
LogFilesSourceCache.AddOrUpdate(newLogFile);
SelectedLogFile = newLogFile;
OpenSelectedLogFile();
}
private void RemoveLogSourceFromLogView(ILogEntriesSource logEntriesSource)
{
if (logEntriesSource is LogFile logFile)
{
_selectedLogView.LogFilePaths.Remove(logFile.NetworkFile.FullName);
LogFilesSourceCache.Refresh(logFile);
}
else if (logEntriesSource is Database database)
{
_selectedLogView.DatabaseNames.Remove(database.Name);
DatabasesSourceCache.Refresh(database);
}
Mediator.NotifyColleagues(MediatorMessages.LogSourceRemovedFromSelectedLogView, logEntriesSource);
}
private void InitializeBindings()
{
LogFilesSourceCache.Connect()
.AutoRefresh(logFile => logFile.IsOpen)
.AutoRefresh(logFile => logFile.RefreshIndicator)
.Sort(SortExpressionComparer <LogFile> .Descending(logFile => logFile.DateLastOpened))
.Filter(logFile => logFile.IsOpen && _selectedLogView != null && _selectedLogView.LogFilePaths.Contains(logFile.NetworkFile?.FullName))
.ObserveOnDispatcher()
.Bind(out _logFiles)
.DisposeMany()
.Subscribe();
DatabasesSourceCache.Connect()
.AutoRefresh(database => database.IsOpen)
.AutoRefresh(database => database.RefreshIndicator)
.Sort(SortExpressionComparer <Database> .Descending(database => database.DateLastOpened))
.Filter(database => database.IsOpen && _selectedLogView != null && _selectedLogView.DatabaseNames.Contains(database.Name))
.ObserveOnDispatcher()
.Bind(out _databases)
.DisposeMany()
.Subscribe();
//FileSizeText = fileWatcher.Latest.Select(fn => fn.Size)
// .Select(size => size.FormatWithAbbreviation())
// .DistinctUntilChanged()
// .ForBinding();
//NumUnfilteredErrors = LogEntriesSourceCache.Connect().ToListObservable()
// .DistinctUntilChanged()
// .ForBinding();
//LogEntriesSourceCache.Items
// .Where(l => (_selectedLogView.LogFilePaths.Contains(l.Identifier) || _selectedLogView.DatabaseNames.Contains(l.Identifier)) && l.Type == LogMessageType.Error)
// .Subscribe(
// NumUnfilteredErrors = 5,
// ex =>
// {
// NumUnfilteredErrors = 0;
// },
// () => { NumUnfilteredErrors = 0; });
}
private async void OpenLogView(LogView logView)
{
logView.Open();
AdjustOpenLogViewCount(1);
RequestSetSelectedLogView(logView);
logView.IsLoading = true;
RequestToggleLaunchViewIsOpen();
await Task.Delay(500);
if (!logView.IsNew && LogViewToOpenDocumentIn == null)
{
OpenableObjectService.SaveOpenableObject(logView);
}
var tasks = new List <Task <ServiceOperationResult> >();
foreach (var logFilePath in logView.LogFilePaths)
{
var logFile = LogFilesSourceCache.Lookup(logFilePath);
if (logFile.HasValue)
{
logFile.Value.Open();
OpenableObjectService.SaveOpenableObject(logFile.Value);
tasks.Add(LogFileService.LoadLogEntriesIntoSourceCacheAsync(logFile.Value, LogEntriesSourceCache));
}
}
foreach (var databaseName in logView.DatabaseNames)
{
var database = DatabasesSourceCache.Lookup(databaseName);
if (database.HasValue)
{
database.Value.Open();
OpenableObjectService.SaveOpenableObject(database.Value);
tasks.Add(DatabaseService.LoadLogEntriesIntoSourceCache(database.Value, LogEntriesSourceCache));
}
}
var results = await Task.WhenAll(tasks);
var failedLogFilesString = string.Empty;
var failedDatabasesString = string.Empty;
var errorMessage = string.Empty;
await Task.Run(() =>
{
for (int i = 0; i < results.Length - logView.DatabaseNames.Count; i++)
{
var result = results[i];
if (result.OperationFailed && logView.LogFilePaths.Count > i)
{
failedLogFilesString += logView.LogFilePaths[i] + "," + Environment.NewLine;
}
}
if (failedLogFilesString.Length > 2)
{
failedLogFilesString = failedLogFilesString.Substring(0, failedLogFilesString.Length - 3);
}
for (int i = logView.LogFilePaths.Count; i < results.Length; i++)
{
var result = results[i];
if (result.OperationFailed)
{
failedDatabasesString += logView.DatabaseNames[i - logView.LogFilePaths.Count] + "," + Environment.NewLine;
}
}
if (failedDatabasesString.Length > 2)
{
failedDatabasesString = failedDatabasesString.Substring(0, failedDatabasesString.Length - 3);
}
if (!string.IsNullOrWhiteSpace(failedLogFilesString))
{
errorMessage += $"Failed to load log entries for the following log files:{Environment.NewLine + failedLogFilesString}";
if (!string.IsNullOrWhiteSpace(failedDatabasesString))
{
errorMessage += $"{Environment.NewLine + Environment.NewLine}Failed to load log entries for the following databases:{Environment.NewLine + failedDatabasesString}";
}
}
else if (!string.IsNullOrWhiteSpace(failedDatabasesString))
{
errorMessage += $"Failed to load log entries for the following databases:{Environment.NewLine + failedDatabasesString}";
}
});
if (!string.IsNullOrWhiteSpace(errorMessage))
{
//TODO: I'm getting this summary error message and individual error messages. Have to disable the error message for each individual log source.
await DialogCoordinator.ShowMessageAsync(this, "Failed to Load Log Entries", errorMessage);
}
//Notify the LogViewManagementViewModel that the AutoRefreshSetting changed so that it can tell databases and log files
Mediator.NotifyColleagues(MediatorMessages.AutoRefreshSettingChanged, logView.Settings.AutoRefresh);
logView.IsLoading = false;
}
private void InitializeBindings()
{
#region Log views
var logViewsSharedSource = LogViewsSourceCache.Connect();
logViewsSharedSource
.AutoRefresh(l => l.DateLastOpened)
.Sort(SortExpressionComparer <LogView> .Descending(l => l.DateLastOpened))
.ObserveOnDispatcher()
.Bind(out var logViews)
.Subscribe();
logViewsSharedSource
.AutoRefresh(l => l.DateLastOpened)
.Sort(SortExpressionComparer <LogView> .Descending(l => l.DateLastOpened))
.Top(_numberInRecents)
.ObserveOnDispatcher()
.Bind(out var recentlyUsedLogViews)
.Subscribe();
logViewsSharedSource
.AutoRefresh(l => l.DateLastOpened)
.AutoRefresh(l => l.IsPinned)
.Filter(l => l.IsPinned)
.Sort(SortExpressionComparer <LogView> .Descending(l => l.DateLastOpened))
.ObserveOnDispatcher()
.Bind(out var pinnedLogViews)
.Subscribe();
LogViews = logViews;
RecentlyUsedLogViews = recentlyUsedLogViews;
PinnedLogViews = pinnedLogViews;
#endregion
#region Log files
var logFilesSharedSource = LogFilesSourceCache.Connect();
logFilesSharedSource
.AutoRefresh(l => l.DateLastOpened)
.Sort(SortExpressionComparer <LogFile> .Descending(l => l.DateLastOpened))
.ObserveOnDispatcher()
.Bind(out var allLogFiles)
.Subscribe();
logFilesSharedSource
.AutoRefresh(l => l.DateLastOpened)
.Sort(SortExpressionComparer <LogFile> .Descending(l => l.DateLastOpened))
.Top(_numberInRecents)
.ObserveOnDispatcher()
.Bind(out var recentlyUsedLogFiles)
.Subscribe();
logFilesSharedSource
.AutoRefresh(l => l.IsPinned)
.AutoRefresh(l => l.DateLastOpened)
.Filter(l => l.IsPinned)
.Sort(SortExpressionComparer <LogFile> .Descending(l => l.DateLastOpened))
.ObserveOnDispatcher()
.Bind(out var pinnedLogFiles)
.Subscribe();
LogFiles = allLogFiles;
RecentlyUsedLogFiles = recentlyUsedLogFiles;
PinnedLogFiles = pinnedLogFiles;
#endregion
#region Databases
var databasesSharedSource = DatabasesSourceCache.Connect();
databasesSharedSource
.ObserveOnDispatcher()
.Bind(out var databases)
.Subscribe();
databasesSharedSource
.AutoRefresh(d => d.DateLastOpened)
.Sort(SortExpressionComparer <Database> .Descending(d => d.DateLastOpened))
.Top(_numberInRecents)
.ObserveOnDispatcher()
.Bind(out var recentlyUsedDatabases)
.Subscribe();
databasesSharedSource
.AutoRefresh(l => l.IsPinned)
.AutoRefresh(d => d.DateLastOpened)
.Filter(l => l.IsPinned)
.Sort(SortExpressionComparer <Database> .Descending(d => d.DateLastOpened))
.ObserveOnDispatcher()
.Bind(out var pinnedDatabases)
.Subscribe();
Databases = databases;
RecentlyUsedDatabases = recentlyUsedDatabases;
PinnedDatabases = pinnedDatabases;
#endregion
#region Searchable openable objects
//TODO: Right now if item added to source caches, this source cache won't see it. Maybe do a join?
//TODO: Need to open search popup when user clicks on search box if there's text in the search box.
AllOpenableObjectsSourceCache.AddOrUpdate(LogViewsSourceCache.Items);
AllOpenableObjectsSourceCache.AddOrUpdate(LogFilesSourceCache.Items);
AllOpenableObjectsSourceCache.AddOrUpdate(DatabasesSourceCache.Items);
AllOpenableObjectsSourceCache.Connect()
.AutoRefresh(d => SearchTerm)
.Filter(o => string.IsNullOrEmpty(SearchTerm) || o.Identifier.ToLower().Contains(SearchTerm.ToLower()))
.ObserveOnDispatcher()
.Bind(out var searchableOpenableObjects)
.Subscribe();
SearchableOpenableObjects = searchableOpenableObjects;
#endregion
}
