public void TestStoreRestore()
{
using (var stream = new MemoryStream())
{
using (var writer = XmlWriter.Create(stream))
{
writer.WriteStartElement("Test");
var settings = new QuickFilters
{
TimeFilter = { SpecialInterval = SpecialDateTimeInterval.ThisWeek }
};
settings.Add(new QuickFilter {
Value = "42"
});
settings.Save(writer);
writer.WriteEndElement();
}
stream.Position = 0;
//Console.WriteLine(Encoding.UTF8.GetString(stream.ToArray()));
using (var reader = XmlReader.Create(stream))
{
reader.MoveToContent();
var settings = new QuickFilters();
settings.Restore(reader);
settings.TimeFilter.SpecialInterval.Should().Be(SpecialDateTimeInterval.ThisWeek);
settings.Should().HaveCount(1);
settings[0].Value.Should().Be("42");
}
}
}
public static bool TryConvertFromPosition(int position, out QuickFilters type)
{
switch (position)
{
case 0:
type = QuickFilters.Default;
return true;
case 1:
type = QuickFilters.Filter1;
return true;
case 2:
type = QuickFilters.Filter2;
return true;
case 3:
type = QuickFilters.Filter3;
return true;
case 4:
type = QuickFilters.Filter4;
return true;
default:
type = QuickFilters.None;
return false;
}
}
public FiltersViewModel(QuickFilters configuration)
{
_configuration = configuration;
_filters = new ObservableCollection <FilterViewModel>();
_addCommand = new DelegateCommand(Add);
}
private void OnOnFiltersChanged()
{
var count = QuickFilters.Count(x => x.IsActive);
QuickInfo = count > 0 ? string.Format("{0} active", count) : null;
OnFiltersChanged?.Invoke();
}
/// <summary>
/// Initializes a new instance of the <see cref="QuickFilterViewModel"/> class.
/// </summary>
/// <param name="quickFilter">The quick filter.</param>
/// <param name="quickFilterList">The quick filter list.</param>
/// <param name="index">The index.</param>
/// <param name="isDefault">if set to <c>true</c> [is default].</param>
public QuickFilterViewModel(QuickFilters quickFilter, IQuickFilterList quickFilterList, int? index, bool isDefault = false)
{
this.IsEnabled = false;
_quickFilterType = quickFilter;
_isDefault = isDefault;
Index = index;
_quickFilterList = quickFilterList;
}
public void TestRoundtripEmpty()
{
var filters = new QuickFilters();
var actualFilters = Roundtrip(filters);
actualFilters.Should().NotBeNull();
actualFilters.Should().BeEmpty();
}
public ApplicationSettings(string fileName)
{
_fileName = Path.GetFullPath(fileName);
_fileFolder = Path.GetDirectoryName(_fileName);
_autoUpdate = new AutoUpdateSettings();
_mainWindow = new WindowSettings();
_dataSources = new DataSources();
_quickFilters = new QuickFilters();
}
public void TestConstruction()
{
var filters = new QuickFilters();
filters.Should().BeEmpty();
filters.TimeFilter.Should().NotBeNull();
filters.TimeFilter.Mode.Should().Be(TimeFilterMode.Everything);
filters.TimeFilter.Minimum.Should().BeNull();
filters.TimeFilter.Maximum.Should().BeNull();
}
private ApplicationSettings(ApplicationSettings other)
{
_fileName = other._fileName;
_fileFolder = other._fileFolder;
_autoUpdate = other._autoUpdate.Clone();
_mainWindow = other._mainWindow.Clone();
_dataSources = other._dataSources.Clone();
_quickFilters = other._quickFilters.Clone();
_export = other._export.Clone();
_logViewer = other._logViewer.Clone();
}
public ApplicationSettings(string fileName)
{
_fileName = Path.GetFullPath(fileName);
_fileFolder = Path.GetDirectoryName(_fileName);
_autoUpdate = new AutoUpdateSettings();
_mainWindow = new MainWindowSettings();
_dataSources = new DataSources();
_quickFilters = new QuickFilters();
_logViewer = new LogViewerSettings();
_export = new ExportSettings();
}
private void OnOnFiltersChanged()
{
var count = QuickFilters.Count(x => x.IsActive);
if (!TimeFilters.SelectEverything)
{
++count;
}
QuickInfo = count > 0 ? string.Format("{0} active", count) : null;
OnFiltersChanged?.Invoke();
}
private void saveBtn_Click(object sender, EventArgs e)
{
var list = dataGridView1.Rows
.OfType <DataGridViewRow>()
.Select(r => r.Cells[COL_Filter].Value?.ToString())
.ToList();
QuickFilters.ReplaceAll(list);
_parent.UpdateFilterDropDown();
this.DialogResult = DialogResult.OK;
this.Close();
}
public void TestClone()
{
var filters = new QuickFilters
{
new QuickFilter
{
MatchType = FilterMatchType.WildcardFilter
}
};
var clone = filters.Clone();
clone.Should().NotBeNull();
clone.Should().NotBeSameAs(filters);
clone.Count.Should().Be(1);
clone[0].Should().NotBeNull();
clone[0].Should().NotBeSameAs(filters[0]);
clone[0].MatchType.Should().Be(filters[0].MatchType);
}
public static int? ConvertToPosition(QuickFilters type)
{
switch (type)
{
case QuickFilters.None:
return null;
case QuickFilters.Default:
return 0;
case QuickFilters.Filter1:
return 1;
case QuickFilters.Filter2:
return 2;
case QuickFilters.Filter3:
return 3;
case QuickFilters.Filter4:
return 4;
default:
throw new ArgumentOutOfRangeException("type", type, @"Quick filter type not supported.");
}
}
public void TestClone()
{
var filters = new QuickFilters
{
new QuickFilter
{
MatchType = FilterMatchType.WildcardFilter
},
};
filters.TimeFilter.SpecialInterval = SpecialDateTimeInterval.Today;
var clone = filters.Clone();
clone.Should().NotBeNull();
clone.Should().NotBeSameAs(filters);
clone.Count.Should().Be(1);
clone[0].Should().NotBeNull();
clone[0].Should().NotBeSameAs(filters[0]);
clone[0].MatchType.Should().Be(filters[0].MatchType);
clone.TimeFilter.Should().NotBeNull();
clone.TimeFilter.SpecialInterval.Should().Be(SpecialDateTimeInterval.Today);
}
public void TestRoundtripTwoFilters()
{
var filters = new QuickFilters();
filters.Add(new QuickFilter
{
IgnoreCase = true,
IsInverted = false,
Value = "A",
MatchType = FilterMatchType.TimeFilter
});
filters.Add(new QuickFilter
{
IgnoreCase = false,
IsInverted = true,
Value = "B",
MatchType = FilterMatchType.SubstringFilter
});
var actualFilters = Roundtrip(filters);
actualFilters.Should().NotBeNull();
actualFilters.Should().HaveCount(2);
actualFilters[0].Id.Should().Be(filters[0].Id);
actualFilters[0].IgnoreCase.Should().BeTrue();
actualFilters[0].IsInverted.Should().BeFalse();
actualFilters[0].Value.Should().Be("A");
actualFilters[0].MatchType.Should().Be(FilterMatchType.TimeFilter);
actualFilters[1].Id.Should().Be(filters[1].Id);
actualFilters[1].IgnoreCase.Should().BeFalse();
actualFilters[1].IsInverted.Should().BeTrue();
actualFilters[1].Value.Should().Be("B");
actualFilters[1].MatchType.Should().Be(FilterMatchType.SubstringFilter);
}
/// <summary>
/// The set quick filter.
/// </summary>
/// <param name="quickFilter">
/// The quick filter.
/// </param>
/// <param name="filterId">
/// The filter id.
/// </param>
public void SetQuickFilter(QuickFilters quickFilter, int filterId)
{
var qfilter = this.QuickFilters.FirstOrDefault(x => x.FilterId == filterId);
if (qfilter != null)
SaveEditQuickFilter(quickFilter, qfilter.Id, filterId);
else
SaveNewQuickFilter(quickFilter, filterId);
}
private static IQuickFilterInfo CreateQuickFilter(QuickFilters quickFilter, int filterId)
{
var filter = Mock.Create<IQuickFilterInfo>(Behavior.Loose);
Mock.Arrange(() => filter.QuickFilter).Returns((int)quickFilter);
Mock.Arrange(() => filter.FilterId).Returns(filterId);
return filter;
}
private void SetQuickFilter(string processName, int filterId, QuickFilters quickFilter)
{
var currentUserQuickFilters = FilterManager.GetCurrentUserQuickFilters(processName);
// Unassign the filter from other quick filters.
foreach (var quickFilterInfo in currentUserQuickFilters.Where(x => x.FilterId == filterId))
{
if (GetQuickFilterType(quickFilterInfo) == quickFilter && GetQuickFilterType(quickFilterInfo) != QuickFilters.None)
{
continue;
}
var quickFilterEdit = DynamicTypeManager.GetEditableRoot<IQuickFilterEdit>(Constants.QuickFilterProcessName, quickFilterInfo.Id);
if (GetQuickFilterType(quickFilterEdit) != QuickFilters.None)
{
quickFilterEdit.FilterId = null;
}
else
{
quickFilterEdit.Delete();
}
quickFilterEdit.Save();
}
if (quickFilter != QuickFilters.None)
{
// Assign the filter to the new quick filter
var quickFilterInfo = currentUserQuickFilters.FirstOrDefault(x => GetQuickFilterType(x) == quickFilter);
if (quickFilterInfo == null)
{
var quickFilterEdit = DynamicTypeManager.NewEditableRoot<IQuickFilterEdit>(Constants.QuickFilterProcessName);
quickFilterEdit.ProcessSystemName = processName;
quickFilterEdit.Account = ToNullable(Utils.CurrentUserAccountId);
quickFilterEdit.QuickFilter = (int)quickFilter;
quickFilterEdit.FilterId = filterId;
quickFilterEdit.Save();
}
else
{
if (quickFilterInfo.FilterId != filterId)
{
var quickFilterEdit = DynamicTypeManager.GetEditableRoot<IQuickFilterEdit>(Constants.QuickFilterProcessName, quickFilterInfo.Id);
quickFilterEdit.FilterId = filterId;
quickFilterEdit.Save();
}
}
}
}
private async Task TurnOffFilter(QuickFilters quickFilter, int skipId)
{
//if (quickFilter == SharedTypes.QuickFilters.None)
//{
// // await this.filterListVm.RefreshFilters();
// // await RefreshQuickFilters();
// //this.RaisePropertyChanged(() => QuickFilterList);
// return;
//}
foreach (var qf in this.QuickFilters)
{
if (skipId == qf.Id) continue;
if (qf.QuickFilter == null) continue;
if (qf.FilterId.HasValue && qf.QuickFilter == (int)quickFilter && quickFilter != SharedTypes.QuickFilters.None)
SaveEditQuickFilter(SharedTypes.QuickFilters.None, qf.Id, (int)qf.FilterId);
}
await this.RefreshQuickFilters();
}
/// <summary>
/// Creates the quick filter.
/// </summary>
/// <param name="quickFilter">The quick filter.</param>
/// <param name="quickFilterList">The quick filter list.</param>
/// <param name="index">The index.</param>
/// <param name="isDefault">if set to <c>true</c> [is default].</param>
/// <returns>IQuickFilterViewModel.</returns>
public IQuickFilterViewModel CreateQuickFilter(QuickFilters quickFilter, IQuickFilterList quickFilterList, int? index, bool isDefault = false)
{
var quickFilterVM = new QuickFilterViewModel(quickFilter, quickFilterList, index, isDefault);
DeploymentService.Container.SatisfyImportsOnce(quickFilterVM);
return quickFilterVM;
}
private static Filter CreateFilter(IFilterEdit filter, QuickFilters quickFilter)
{
return new Filter
{
ProcessSystemName = filter.ProcessSystemName,
Id = filter.Id,
Name = filter.Name,
FilterDefinition = ConvertMemberTypesToDataTypes(filter.FilterDefinition),
IsAdminFilter = filter.IsAdminFilter ?? false,
LayoutId = ToNullable(filter.DefaultLayout),
QuickFilter = quickFilter
};
}
private ILogEntryFilter CreateFilter(QuickFilters configurationQuickFilters)
{
return(Filter.Create(configurationQuickFilters.Select(x => x.CreateFilter())));
}
public LogEntryCountAnalyserConfiguration()
{
_quickFilters = new QuickFilters();
}
public void SetUp()
{
_settings = new QuickFilters();
}
private void SaveNewQuickFilter(QuickFilters quickFilter, int filterId)
{
TheDynamicTypeManager.Value.BeginNewEditableRoot<IQuickFilterEdit>(
Constants.QuickFilterProcessName,
async (s, e) =>
{
if (e.Error == null)
{
await SaveQuickFilter(quickFilter, e.Object, filterId);
}
else
{
ThePopupFactory.Value.NotifyFailure(e.Error);
}
});
}
private void UnassignFilterFromQuickFilter(string processName, QuickFilters quickFilter)
{
var currentUserQuickFilters = FilterManager.GetCurrentUserQuickFilters(processName);
foreach (var quickFilterInfo in currentUserQuickFilters)
{
if (GetQuickFilterType(quickFilterInfo) == quickFilter)
{
var quickFilterEdit = DynamicTypeManager.GetEditableRoot<IQuickFilterEdit>(Constants.QuickFilterProcessName, quickFilterInfo.Id);
quickFilterEdit.FilterId = null;
quickFilterEdit.Save();
}
}
}
private async Task SaveQuickFilter(QuickFilters quickFilter, IQuickFilterEdit quickfilterEdit, int filterId)
{
quickfilterEdit.ProcessSystemName = ProcessSystemName;
quickfilterEdit.QuickFilter = (int)quickFilter;
quickfilterEdit.FilterId = filterId;
quickfilterEdit.Account = Utils.CurrentUserAccountId == -1 ? null : (int?)Utils.CurrentUserAccountId;
await ((ISavable)quickfilterEdit).SaveAsync();
await TurnOffFilter(quickFilter, quickfilterEdit.Id);
}
private QuickFilters Roundtrip(QuickFilters quickFilters)
{
return(quickFilters.Roundtrip(typeof(QuickFilter), typeof(QuickFilterId)));
}
private void AddFilterBtn_Click(object sender, EventArgs e)
{
QuickFilters.Add(this.filterSearchTb.Text);
UpdateFilterDropDown();
}
public void SetUp()
{
_settings = new QuickFilters();
}
