public void ParseConfig_WrongAttributeValue_Throws()
{
var input = new XElement("Tracer",
new XElement("TraceOn", new XAttribute("class", "wrongvalue"), new XAttribute("method", "private"))
);
Action runParse = () => DefaultFilter.ParseConfig(input.Descendants());
runParse.ShouldThrow <ApplicationException>();
}
public void ParseConfig_MissingAttribute_Throws()
{
var input = new XElement("Tracer",
new XElement("TraceOn", new XAttribute("method", "private"))
);
Action runParse = () => DefaultFilter.ParseConfig(input.Descendants());
runParse.Should().Throw <Exception>();
}
/// <summary>
/// Добавляется элемент в таблицу данных
/// </summary>
/// <param name="directive">Добавлямая директива</param>
/// <param name="destinationDataSet">Таблица, в которую добавляется элемент</param>
public virtual void AddDirectiveToDataset(BaseDetailDirective directive, DirectiveListReportDataSet destinationDataSet)
{
if (!DefaultFilter.Acceptable(directive))
{
return;
}
string applicability = directive.Applicability;
//if (applicability == null || string.IsNullOrEmpty(applicability)) applicability = "-";
string remarks = directive.Remarks;
string description = directive.Description;
string title = directive.Title;
string references = directive.References;
string condition = directive.Condition.ToString();
condition = condition.Substring(0, 5);
if (directive.Closed)
{
condition = "Close";
}
string effectivityDate = directive.EffectivityDate.ToString("MMM dd, yyyy");
string ThresholdSinceNew =
lifelengthFormatter.GetData(directive.FirstPerformSinceNew, "h\r\n", "cyc\r\n", "");
string thresholdSInceEffectivityDate =
lifelengthFormatter.GetData(directive.SinceEffectivityDatePerformanceLifelength, "h\r\n", "cyc\r\n", "");
string repearIntervals = lifelengthFormatter.GetData(directive.RepeatPerform, "h\r\n", "cyc\r\n", "");
string compliance = lifelengthFormatter.GetData(directive.LastPerformanceLifelength, "h\r\n", "cyc\r\n", "");
string complianceDate = "-";
if (directive.LastPerformance != null)
{
complianceDate = directive.LastPerformance.RecordsAddDate.ToString("MMM dd, yyyy");
}
string nextLifelength = lifelengthFormatter.GetData(directive.NextPerformance, "h\r\n", "cyc\r\n", "");
string nextDate = "-"; //todo
string leftTillNext = lifelengthFormatter.GetData(directive.LeftTillNextPerformance, "h\r\n", "cyc\r\n", "");
int parentID = directive.Parent.ID;
if (directive.Parent is AircraftContainer)
{
parentID = directive.Parent.Parent.ID;
}
destinationDataSet.ItemsTable.AddItemsTableRow(directive.ID,
destinationDataSet.BaseDetailTable.FindByBaseDetailID(
parentID), applicability,
remarks, description, title,
references, condition,
effectivityDate,
ThresholdSinceNew,
thresholdSInceEffectivityDate,
repearIntervals,
compliance, complianceDate,
nextLifelength,
nextDate,
leftTillNext);
}
public void ParseConfig_PrivateConfig_Parsed()
{
var input = new XElement("Tracer",
new XElement("TraceOn", new XAttribute("class", "internal"), new XAttribute("method", "private"))
);
var parseResult = DefaultFilter.ParseConfig(input.Descendants()).ToList();
parseResult.Count.Should().Be(1);
parseResult[0].TargetClass.Should().Be(DefaultFilter.TraceTargetVisibility.InternalOrMoreVisible);
parseResult[0].TargetMethod.Should().Be(DefaultFilter.TraceTargetVisibility.All);
}
public void ParseConfig_DefaultConfig_Parsed()
{
var input = new XElement("Tracer",
new XElement("TraceOn", new XAttribute("class", "public"), new XAttribute("method", "public"))
);
var parseResult = DefaultFilter.ParseConfig(input.Descendants()).ToList();
parseResult.Count.Should().Be(1);
parseResult[0].Should().BeOfType <AssemblyLevelTraceOnDefinition>();
((AssemblyLevelTraceOnDefinition)parseResult[0]).TargetClass.Should().Be(TraceTargetVisibility.Public);
((AssemblyLevelTraceOnDefinition)parseResult[0]).TargetMethod.Should().Be(TraceTargetVisibility.Public);
}
public void Parse_MultiElement_Configuration()
{
var result = DefaultFilter.ParseConfig(XElement.Parse(@"<root>
<TraceOn class=""public"" method =""public"" />
<TraceOn namespace=""rootnamespace"" class=""public"" method =""public"" />
<NoTrace namespace=""rootnamespace.other"" />
</root>").Descendants()).ToList();
result.Count.Should().Be(3);
result[0].Should().BeOfType <AssemblyLevelTraceOnDefinition>();
result[1].Should().BeOfType <AssemblyLevelTraceOnDefinition>();
result[2].Should().BeOfType <AssemblyLevelNoTraceDefinition>();
}
public void ParseConfig_PrivateConfig_Parsed()
{
XElement input = new XElement("Tracer",
new XElement("TraceOn", new XAttribute("class", "internal"), new XAttribute("method", "private"))
);
List <AssemblyLevelTraceDefinition> parseResult = DefaultFilter.ParseConfig(input.Descendants()).ToList();
parseResult.Count.Should().Be(1);
parseResult[0].Should().BeOfType <AssemblyLevelTraceOnDefinition>();
((AssemblyLevelTraceOnDefinition)parseResult[0]).TargetClass.Should().Be(TraceTargetVisibility.InternalOrMoreVisible);
((AssemblyLevelTraceOnDefinition)parseResult[0]).TargetMethod.Should().Be(TraceTargetVisibility.All);
}
/// <summary>
/// Добавляется элемент в таблицу данных
/// </summary>
/// <param name="detail">Добавляемый агрегат</param>
/// <param name="number">Порядковый номер агрегата</param>
/// <param name="destinationDataSet">Таблица, в которую добавляется элемент</param>
protected virtual void AddDetailToDataset(Detail detail, int number, DetailListDataSet destinationDataSet)
{
if (!DefaultFilter.Acceptable(detail))
{
return;
}
int aircraftId = ReportedAircraft.ID;
string atachapter = detail.AtaChapter.ShortName;
string componentNumber = number.ToString();
string atachapterfull = detail.AtaChapter.FullName;
string partNumber = detail.PartNumber;
string description = detail.Description;
string serialNumber = detail.SerialNumber;
string positionNumber = detail.PositionNumber;
string maintanceType = detail.MaintenanceType.ShortName;
string instalationDate = detail.InstallationDate.ToString("MMM dd, yyyy");
string complianceTSN = "";
string complianceDate = "";
string complianceWorkType = "";
if (detail.Limitation.LastPerformance != null)
{
complianceTSN = lifelengthFormatter.GetData(detail.Limitation.LastPerformance.Lifelength, "h\r\n", "cyc\r\n", "");
DateTime tempDateTime = new DateTime(detail.Limitation.LastPerformance.Lifelength.Calendar.Ticks);
complianceDate = tempDateTime.ToString("MMM dd, yyyy");
complianceWorkType = detail.Limitation.LastPerformance.DetailRecordType.ShortName;
}
string nextTSN = "";
string nextDate = "";
string nextRemains = "";
string nextWorkType = "";
if (detail.Limitation.NextPerformance != null)
{
}
string condition = detail.LimitationCondition.GetHashCode().ToString();
destinationDataSet.ItemsTable.AddItemsTableRow(detail.ID, aircraftId, componentNumber,
atachapter, atachapterfull, partNumber, description,
serialNumber, positionNumber,
maintanceType,
instalationDate,
complianceTSN,
complianceDate,
complianceWorkType, nextTSN,
nextDate,
nextRemains,
nextWorkType, condition);
}
async Task <IEnumerable <Supplier> > IBaseInterface <Supplier> .GetAll(DefaultFilter df)
{
if (!String.IsNullOrEmpty(df.Orderby) && df.IsDesc)
{
return(await _context.Supplier.OrderBy(df.Orderby + " desc").ToListAsync());
}
if (!String.IsNullOrEmpty(df.Orderby))
{
return(await _context.Supplier.OrderBy(df.Orderby).ToListAsync());
}
return(await _context.Supplier.OrderBy(x => x.SupplierId).ToListAsync());
}
async Task <IEnumerable <Category> > IBaseInterface <Category> .GetAll(DefaultFilter df)
{
if (!String.IsNullOrEmpty(df.Orderby) && df.IsDesc)
{
return(await _context.Category.OrderBy(df.Orderby + " desc").ToListAsync());
}
if (!String.IsNullOrEmpty(df.Orderby))
{
return(await _context.Category.OrderBy(df.Orderby).ToListAsync());
}
return(await _context.Category.ToListAsync());
}
public IFilter CreateFilter(IFilterViewModel filterViewModel)
{
switch (filterViewModel)
{
case FilterViewModel defaultFilterViewModel:
var res = new DefaultFilter();
res.Conditions = defaultFilterViewModel.ConditionViewModels
.Select(model => _conditionFillHelper.CreateConditionFromViewModel(model))
.Where(condition => condition != null)
.ToList();
res.Name = filterViewModel.Name;
return(res);
}
return(null);
}
private void BuildFilterEntry(string description, DefaultFilter filter, Guid?pluginId = null)
{
// Find the proper DefaultFilter object for this item.
var foundFilter = _visibleFilters.FirstOrDefault(f => f.Filter == filter && (f.Filter != DefaultFilter.Plugin || f.PluginId == pluginId));
// Create the default settings
if (foundFilter == null)
{
foundFilter = filter == DefaultFilter.Plugin ? new VisibleFilter(filter)
{
PluginId = pluginId, Visible = true
}
}
: new VisibleFilter(filter)
{
Visible = true
};
// Add the entry to the list
var entry = new VisibleFilterEntry(foundFilter, description);
lstFilters.Items.Add(entry, foundFilter.Visible);
}
public void MigemoTest()
{
if (!Migemo.IsEnable())
{
var solutionDir = Directory.GetParent(Directory.GetParent(Directory.GetParent(Directory.GetParent(System.Reflection.Assembly.GetExecutingAssembly().Location).FullName).FullName).FullName).FullName;
var settings = UIAssistantAPI.Instance.UIAssistantSettings;
settings.UseMigemo = true;
settings.MigemoDllPath = Path.Combine(solutionDir, "assemblies", "Migemo");
settings.MigemoDictionaryPath = Path.Combine(solutionDir, "assemblies", "Migemo", "dict", "migemo-dict");
}
var migemoFilter = new DefaultFilter();
if (!Migemo.IsEnable())
{
// Fail: Migemo initialize
Assert.Fail();
}
var results = migemoFilter.Filter(_collection, "gamen");
Assert.AreEqual(9, results.Count());
results = migemoFilter.Filter(_collection, "здравствуйте");
Assert.AreEqual(1, results.Count());
}
public void IncludesAndExcludes_NotMatchingElement_ElementIsNotAccepted()
{
IFilter filter = new DefaultFilter(new[] { "+Test", "-Test" });
Assert.IsFalse(filter.IsElementIncludedInReport("Test"), "Element is expected to be excluded.");
}
public void IncludesAndExcludes_MatchingElement_ElementIsAccepted()
{
IFilter filter = new DefaultFilter(new[] { "+Test", "-SomeExclude" });
Assert.IsTrue(filter.IsElementIncludedInReport("Test"), "Element is expected to be included.");
}
public void NoFilter_AnyElement_ElementIsAccepted()
{
IFilter filter = new DefaultFilter(new string[] { });
Assert.IsTrue(filter.IsElementIncludedInReport("Test"), "Element is expected to be included.");
}
public VisibleFilter(DefaultFilter filter)
{
this.Filter = filter;
}
async Task <IEnumerable <Category> > IBaseInterface <Category> .GetList(DefaultFilter df)
{
return(await _context.Category.Where(x => x.Enabled == true && x.ParentCategoryId == df.Id).ToListAsync());
}
async Task <Paging <ParentCategory> > IBaseInterface <ParentCategory> .Search(DefaultFilter df)
{
Paging <ParentCategory> resault = new Paging <ParentCategory>();
resault.TotalPages = (int)Math.Ceiling((double)_context.ParentCategory.Count() / df.MaxPageSize);
resault.CurrentPage = df.PageNumber;
if (!String.IsNullOrEmpty(df.Orderby) && df.IsDesc)
{
resault.Data = await _context.ParentCategory.Where(x => x.ParentCategoryId.ToString().Contains(df.Filter) || x.EName.Contains(df.Filter) || x.AName.Contains(df.Filter) || x.DataComment.Contains(df.Filter))
.OrderBy(df.Orderby + " desc").Skip((int)((df.PageNumber - 1) * df.MaxPageSize)).Take(df.MaxPageSize).ToListAsync();
return(resault);
}
if (!String.IsNullOrEmpty(df.Orderby))
{
resault.Data = await _context.ParentCategory.Where(x => x.ParentCategoryId.ToString().Contains(df.Filter) || x.EName.Contains(df.Filter) || x.AName.Contains(df.Filter) || x.DataComment.Contains(df.Filter))
.OrderBy(df.Orderby).Skip((int)((df.PageNumber - 1) * df.MaxPageSize)).Take(df.MaxPageSize).ToListAsync();
return(resault);
}
resault.Data = await _context.ParentCategory.Where(x => x.ParentCategoryId.ToString().Contains(df.Filter) || x.EName.Contains(df.Filter) || x.AName.Contains(df.Filter) || x.DataComment.Contains(df.Filter))
.Skip((int)((df.PageNumber - 1) * df.MaxPageSize)).Take(df.MaxPageSize).ToListAsync();
return(resault);
}
public void ClearElements()
{
FilterArray = new DefaultFilter(FilterSizeInBits);
}
Task <Paging <Uom> > IBaseInterface <Uom> .Search(DefaultFilter df)
{
throw new System.NotImplementedException();
}
async Task <IEnumerable <Uom> > IBaseInterface <Uom> .GetList(DefaultFilter df)
{
return(await _context.Uom.Where(x => x.Enabled == true).ToListAsync());
}
public void Creation_MultiElementConfig()
{
var filter = new DefaultFilter(XElement.Parse(@"<root>
<TraceOn class=""public"" method =""public"" />
<TraceOn namespace=""rootnamespace"" class=""public"" method =""public"" />
<NoTrace namespace=""rootnamespace.other"" />
</root>").Descendants());
string code = @"
using TracerAttributes;
namespace rootnamespace
{
public class MyClass
{
public void PublicMethod()
{}
internal void InternalMethod()
{}
protected void ProtectedMethod()
{}
private void PrivateMethod()
{}
}
}
namespace rootnamespace.other
{
public class OtherClass
{
public void OtherPublicMethod()
{}
}
}
namespace rootnamespace.another
{
public class AnotherClass
{
public void AnotherPublicMethod()
{}
}
}
";
var publicMethodDef = GetMethodDefinition(code, "PublicMethod");
var internalMethodDef = GetMethodDefinition(code, "InternalMethod");
filter.ShouldAddTrace(publicMethodDef).Should().BeTrue();
filter.ShouldAddTrace(internalMethodDef).Should().BeFalse();
var otherPublicMethodDef = GetMethodDefinition(code, "OtherPublicMethod");
filter.ShouldAddTrace(otherPublicMethodDef).Should().BeFalse();
var anotherPublicMethodDef = GetMethodDefinition(code, "AnotherPublicMethod");
filter.ShouldAddTrace(anotherPublicMethodDef).Should().BeTrue();
}
Task <Paging <Models.Type> > IBaseInterface <Models.Type> .Page(DefaultFilter df)
{
throw new System.NotImplementedException();
}
private bool IsChecked(DefaultFilter filter, Guid?pluginId = null)
{
return(lstFilters.CheckedItems.Cast <VisibleFilterEntry>().Any(e => e.Filter.Filter == filter && e.Filter.PluginId == pluginId));
}
async Task <IEnumerable <Supplier> > IBaseInterface <Supplier> .GetList(DefaultFilter df)
{
return(await _context.Supplier.Where(x => x.Enabled == true && x.SellerId == _sellerId).ToListAsync());
}
public void GroupFilterSaveLoad()
{
var configurationEditorViewModel = _typesContainer.Resolve <IFragmentEditorViewModel>(
ApplicationGlobalNames.FragmentInjectcionStrings.CONFIGURATION +
ApplicationGlobalNames.CommonInjectionStrings.EDITOR_VIEWMODEL) as ConfigurationEditorViewModel;
var rootGroup = new ConfigurationGroupEditorViewModel()
{
Name = "root"
};
rootGroup.FilterViewModels.AddRange(new ObservableCollection <IFilterViewModel>()
{
new FilterViewModel(new ObservableCollection <IConditionViewModel>())
{
Name = "F1"
},
new FilterViewModel(new ObservableCollection <IConditionViewModel>()
{
new CompareConditionViewModel(new List <string>()
{
"c1"
})
{
SelectedCondition = ConditionsEnum.Equal.ToString(),
UshortValueToCompare = 1
}
})
{
Name = "F2"
}
});
configurationEditorViewModel.RootConfigurationItemViewModels.Add(rootGroup);
var result = ConfigurationFragmentFactory.CreateConfiguration(configurationEditorViewModel);
var groupFilter = (result.RootConfigurationItemList[0] as IItemsGroup).GroupFilter as GroupFilterInfo;
Assert.True(groupFilter.Filters.Count == 2);
DefaultFilter defaultFilter1 = groupFilter.Filters[0] as DefaultFilter;
DefaultFilter defaultFilter2 = groupFilter.Filters[1] as DefaultFilter;
Assert.True(defaultFilter1.Conditions.Count == 0);
Assert.True(defaultFilter1.Name == "F1");
Assert.True(defaultFilter2.Conditions.Count == 1);
Assert.True(defaultFilter2.Name == "F2");
var condition = defaultFilter2.Conditions[0] as CompareCondition;
Assert.True(condition.ConditionsEnum == ConditionsEnum.Equal);
Assert.True(condition.UshortValueToCompare == 1);
ConfigurationItemEditorViewModelFactory configurationItemEditorViewModelFactory =
ConfigurationItemEditorViewModelFactory.Create();
var loadedRootItem =
configurationItemEditorViewModelFactory.VisitItemsGroup(
result.RootConfigurationItemList[0] as IItemsGroup);
FilterViewModel filterViewModel1 =
(loadedRootItem as IConfigurationGroupEditorViewModel).FilterViewModels[0] as FilterViewModel;
FilterViewModel filterViewModel2 =
(loadedRootItem as IConfigurationGroupEditorViewModel).FilterViewModels[1] as FilterViewModel;
Assert.True(filterViewModel1.Name == "F1");
Assert.True(filterViewModel2.Name == "F2");
Assert.True(filterViewModel1.ConditionViewModels.Count == 0);
Assert.True(filterViewModel2.ConditionViewModels.Count == 1);
CompareConditionViewModel compareConditionViewModel =
filterViewModel2.ConditionViewModels[0] as CompareConditionViewModel;
Assert.True(compareConditionViewModel.SelectedCondition == ConditionsEnum.Equal.ToString());
Assert.True(compareConditionViewModel.UshortValueToCompare == 1);
}
public FilterDataLogic(DefaultFilter defaultFilter)
{
cLeft = 1;
this.defaultFilter = defaultFilter;
}
async Task <IEnumerable <ParentCategory> > IBaseInterface <ParentCategory> .GetList(DefaultFilter df)
{
var obj = await _context.Seller.Where(x => x.SellerId == _sellerId).FirstOrDefaultAsync();
var typeid = obj.TypeId;
return(await _context.ParentCategory.Where(x => x.Enabled == true && x.TypeId == typeid).ToListAsync());
}
