public AggregateRowQuerierBuilder <THistoricalTable> AddWhereInFilter <TField, TValueType>(Expression <Func <THistoricalTable, TField> > fieldNameDescriptor, List <TValueType> listItems) { var filterDescription = new FilterDescription <THistoricalTable>() .SetWhereInFilter(fieldNameDescriptor, listItems); return(AddArbitraryFilter(filterDescription)); }
private static string AddСondition(FilterDescription filter, List <FindHandler.FieldParameters> listOfField) { string result = ""; var field = listOfField.Where(kvp => kvp.application_name == filter.field).First().db_name; var typeFilter = TakeFilter(filter.typeOfFilter); if (filter.typeOfFilter == TypeOfFilter.TypesOfFilter.isFilled) { result += "NOT "; } if (!filter.isDate) { result += string.Format(field + " " + typeFilter + "\"{0}\"", filter.value); } else { string day = filter.value.Substring(0, 2); string month = filter.value.Substring(3, 2); string year = filter.value.Substring(6, 4); result += string.Format(field + " " + typeFilter + " \'{0}-{1}-{2}\'", year, month, day); //result += string.Format(" DATE_FORMAT(" + field + ", '%d.%m.%Y') = \'{0}\'", filter.value); } /*if (filter.typeOfFilter == TypeOfFilter.TypesOfFilter.contains) * { * result += ") "; * }*/ return(result); }
public AggregateRowQuerierBuilder <THistoricalTable> AddWhereEqualsToFilter <TField>(Expression <Func <THistoricalTable, TField> > fieldNameDescriptor, object value) { var filterDescription = new FilterDescription <THistoricalTable>() .SetWhereEqualToFilter(fieldNameDescriptor, value); return(AddArbitraryFilter(filterDescription)); }
public ParsedFilter Parse(FilterDescription definition, CommerceDataSourceContext context) { var paramValues = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); foreach (var paramDef in definition.Parameters) { var param = ParameterValues.Find(p => p.ParameterName.Equals(paramDef.Name, StringComparison.OrdinalIgnoreCase)); // Parameter is required but it's missing in data source settings (might cause by code changes). Parse failed. if (paramDef.Required && param == null) { return(null); } var strParamValue = ParameterizedFieldValue.GetFieldValue(param.ParameterValue, context.ValueProvider); // Parameter is required but it's missing in current context. Parse failed. if (paramDef.Required && strParamValue == null) { return(null); } var paramValue = StringConvert.ToObject(strParamValue, paramDef.ValueType); paramValues.Add(paramDef.Name, paramValue); } return(new ParsedFilter(definition.Name) { ParameterValues = paramValues }); }
internal static void CreateNca(Option option) { AuthoringConfiguration config = option.Config; CreateNcaOption createNca = option.CreateNca; Directory.CreateDirectory(Path.GetDirectoryName(createNca.OutputFile)); string str = createNca.InputAdfFile; if (createNca.ContentType != null) { List <Pair <FilterType, Regex> > fdf = FilterDescription.ParseFdf(createNca.InputFdfPath); str = Path.GetDirectoryName(createNca.OutputFile) + "\\" + Path.GetFileName(createNca.OutputFile) + ".adf"; new NintendoContentAdfWriter(str, createNca.ContentType, createNca.MetaFilePath, createNca.DescFilePath, createNca.KeyAreaEncryptionKeyIndex).Write(createNca.InputDirs, fdf); } if (createNca.IsOnlyAdf) { return; } if (ContentArchiveLibraryInterface.GetArchiveType(str) != ArchiveFormatType.NintendoContent) { throw new FormatException("invalid formatType is indicated by .adf file."); } using (FileStream fileStream = Program.OpenNewFileStream(createNca.OutputFile, FileOptions.RandomAccess)) ContentArchiveLibraryInterface.CreateArchiveFromAdf((Stream)fileStream, str, config); if (createNca.IsSaveAdf) { return; } File.Delete(str); File.Delete(Path.GetDirectoryName(str) + "\\" + Path.GetFileNameWithoutExtension(str) + ".code.adf"); File.Delete(Path.GetDirectoryName(str) + "\\" + Path.GetFileNameWithoutExtension(str) + ".rom.adf"); }
public FilterModel(FilterDescription filter) { Name = filter.Name; Parameters = filter.Parameters.Select(p => new FilterParameterModel { Name = p.Name }) .ToList(); }
public AggregateRowQuerierBuilder <THistoricalTable> AddArbitraryFilter(FilterDescription <THistoricalTable> filterDescription) { InnerQBuilder.UseTableBoundFilter <THistoricalTable>() .Where(filterDescription); ResultQbuilder.UseTableBoundFilter <THistoricalTable>() .Where(filterDescription); return(this); }
public static void Main(params string[] args) { var filter = new FilterDescription() { PatternType = FilterDescription.FilterPatternType.Contains, Field = "FirstName", FilterPhrase = "ed" }; var filtered = GetPersons().Filter(filter); }
public WhereConjuntionBuilder Where <TTable> (FilterDescription <TTable> filterDescription) { if (filterDescription.FilterSet) { return(Where <TTable> (filterDescription.FieldName, filterDescription.Filter)); } else { return(_whereConjunctionBuilder); } }
public static string ParsePropertyValue(FilterDescription filter) { switch (filter.PatternType) { case FilterDescription.FilterPatternType.Contains: return(string.Format("%{0}%", filter.FilterPhrase)); case FilterDescription.FilterPatternType.Range: return(string.Format("[^{0}]", filter.FilterPhrase)); default: throw new InvalidOperationException("Pattern type not supported"); } }
public static IBaseFilter AddFilter(this IGraphBuilder pGraphBuilder, FilterDescription filterDescription) { var baseFilter = DsUtils.GetFilter(filterDescription.ClassId, true); var hr = pGraphBuilder.AddFilter(baseFilter, filterDescription.Name); if (DsHlp.FAILED(hr)) { Marshal.FinalReleaseComObject(baseFilter); hr.ThrowExceptionForHR(); } return(baseFilter); }
// Execute the next operation requested in the operations list void ExecuteOperation(object operation) { if (operation != null) { IsLeaf = false; if (operation is FilterDescription) { FilterDescription filterOperation = (FilterDescription)operation; // both cannot be null and both cannot be not null if (filterOperation.FilterUsingAnEvent != null) { Filter(filterOperation.FilterUsingAnEvent); } else { Filter(filterOperation.FilterUsingAPredicate); } } else if (operation is PropertySortDescription) { PropertySortDescription sortOperation = (PropertySortDescription)operation; if (sortOperation.Comparer == null) { Sort(sortOperation); } else { CustomSort(sortOperation); } } else if (operation is INTERNAL_PropertyGroupDescription) { INTERNAL_PropertyGroupDescription groupOperation = (INTERNAL_PropertyGroupDescription)operation; GroupBy(groupOperation); } else { throw new InvalidOperationException("unknow operation type"); } } else // if the operation to do on this view is null, that mean we have reach the end of the operation list and this view is usable as data source { IsLeaf = true; } }
internal static void CreateFs(Option option) { AuthoringConfiguration config = option.Config; CreateFsOption createFs = option.CreateFs; Directory.CreateDirectory(Path.GetDirectoryName(createFs.OutputFile)); string str = createFs.InputAdfFile; if (createFs.Format != ArchiveFormatType.Invalid) { List <Pair <FilterType, Regex> > fdf = FilterDescription.ParseFdf(createFs.InputFdfPath); str = Path.GetDirectoryName(createFs.OutputFile) + "\\" + Path.GetFileName(createFs.OutputFile) + ".adf"; switch (createFs.Format) { case ArchiveFormatType.PartitionFs: new PartitionFsAdfWriter(str).Write(createFs.InputDir); break; case ArchiveFormatType.RomFs: new RomFsAdfWriter(str).Write(createFs.InputDir, fdf); break; default: throw new NotImplementedException(); } } if (createFs.IsOnlyAdf) { return; } switch (ContentArchiveLibraryInterface.GetArchiveType(str)) { case ArchiveFormatType.PartitionFs: case ArchiveFormatType.RomFs: using (FileStream fileStream = Program.OpenNewFileStream(createFs.OutputFile, FileOptions.RandomAccess)) ContentArchiveLibraryInterface.CreateArchiveFromAdf((Stream)fileStream, str, config); if (createFs.IsSaveAdf) { break; } File.Delete(str); break; default: throw new FormatException("invalid formatType is indicated by .adf file."); } }
internal static void CreateNsp(Option option) { AuthoringConfiguration config = option.Config; CreateNspOption createNsp = option.CreateNsp; Directory.CreateDirectory(Path.GetDirectoryName(createNsp.OutputFile)); if (createNsp.GeneratesApplicationControl) { ApplicationControl.Generate(createNsp.NspContentInfos[0].MetaFilePath, createNsp.NspContentInfos[0].IconList, createNsp.NspContentInfos[0].NxIconList, createNsp.NspContentInfos[0].NxIconMaxSize, createNsp.GetApplicationControlGeneratePath(), true); } string str = createNsp.InputAdfFile; if (str == null) { List <Pair <FilterType, Regex> > fdf = FilterDescription.ParseFdf(createNsp.InputFdfPath); str = Path.GetDirectoryName(createNsp.OutputFile) + "\\" + Path.GetFileName(createNsp.OutputFile) + ".adf"; new NintendoSubmissionPackageAdfWriter(str).Write(createNsp.NspContentInfos, fdf); } if (createNsp.IsOnlyAdf) { return; } if (ContentArchiveLibraryInterface.GetArchiveType(str) != ArchiveFormatType.NintendoSubmissionPackage) { throw new FormatException("invalid formatType is indicated by .adf file."); } using (FileStream fileStream = Program.OpenNewFileStream(createNsp.OutputFile, FileOptions.RandomAccess)) ContentArchiveLibraryInterface.CreateArchiveFromAdf((Stream)fileStream, str, config); if (!createNsp.IsSaveAdf) { File.Delete(str); foreach (string file in Directory.GetFiles(Path.GetDirectoryName(str), Path.GetFileNameWithoutExtension(str) + ".c?.*.nca.*adf")) { File.Delete(file); } } if (!createNsp.GeneratesApplicationControl) { return; } Directory.Delete(createNsp.GetApplicationControlGeneratePath(), true); }
/// <summary> /// Determine whether or not the given step is capable of being /// placed in one-to-one correspondence with this step. Steps are /// defined to be matching if both steps have equivalent name, /// index lookup records and owned lists of sub-steps. /// </summary> /// <param name="step"> /// The <b>IStep</b> to be checked. /// </param> /// <returns> /// True iff the given step matches with this step. /// </returns> public bool IsMatching(IStep step) { if (FilterDescription.Equals(step.FilterDescription) && IndexLookupRecords.Equals(step.IndexLookupRecords)) { IList listSteps = step.Steps; if (m_listSubSteps.Count == listSteps.Count) { int i = 0; foreach (Step subStep in m_listSubSteps) { if (!subStep.IsMatching((IStep)listSteps[i++])) { return(false); } } return(true); } } return(false); }
private void OnFilter(object sender, FilterEventArgs e) { e.Accepted = FilterDescription?.Invoke(e.Item) ?? true; }
public FilterDescriptionExpressionBuilder(ParameterExpression parameterExpression, FilterDescription filterDescription) : base(parameterExpression) { this.filterDescription = filterDescription; }
public WhereConjuntionBuilder Where(FilterDescription <TTable> filterDescription) { return(_whereBuilder.Where(filterDescription)); }
/// <summary> /// Construtor padrão. /// </summary> /// <param name="parameterExpression"></param> /// <param name="filterDescription"></param> public FilterDescriptionExpressionBuilder(System.Linq.Expressions.ParameterExpression parameterExpression, FilterDescription filterDescription) : base(parameterExpression) { _filterDescription = filterDescription; }
private static string GetLinqQueryString(FilterDescription filterDescription) { string ret = ""; if (!string.IsNullOrWhiteSpace(filterDescription.Filter)) { // using user str + linq.dynamic try { // xceed syntax : empty (contains), AND (uppercase), OR (uppercase), <>, * (end with), =, >, >=, <, <=, * (start with) // see http://doc.xceedsoft.com/products/XceedWpfDataGrid/Filter_Row.html // linq.dynamic syntax : =, ==, <>, !=, <, >, <=, >=, &&, and, ||, or, x.m(…) (where x is the attrib and m the function (ex: Contains, StartsWith, EndsWith ...) // see D:\DevC#\VirtualisingCollectionTest1\DynamicQuery\Dynamic Expressions.html // ex : RemoteOrDbDataSourceEmulation.Instance.Items.Where( "Name.Contains(\"e_1\") or Name.Contains(\"e_2\")" ); string exp = filterDescription.Filter; // arrange expression bool previousTermIsOperator = false; foreach (Match match in _regexSplit.Matches(exp)) { if (match.Success) { //TODO processing results if (_regexOp.IsMatch(match.Value)) { if (_regexComparOp.IsMatch(match.Value)) { // simple operator >, <, ==, != ... ret += " " + filterDescription.PropertyName + " " + match.Value; previousTermIsOperator = true; } else { // and, or ... ret += " " + match.Value; previousTermIsOperator = false; } } else { // Value if (previousTermIsOperator) { ret += " " + match.Value; previousTermIsOperator = false; } else { if (match.Value.StartsWith("*")) { ret += " " + filterDescription.PropertyName + ".EndsWith( \"" + match.Value.Substring(1) + "\" )"; } else if (match.Value.EndsWith("*")) { ret += " " + filterDescription.PropertyName + ".StartsWith( \"" + match.Value.Substring(0, match.Value.Length - 1) + "\" )"; } else { ret += " " + filterDescription.PropertyName + ".Contains( \"" + match.Value + "\" )"; } previousTermIsOperator = false; } } } } } catch (Exception) { } } return(ret); }
private IList <Condition> ParseConditions() { bool conditionExist = false; IList <Condition> conditions = new List <Condition>(); if (FilterSeverity != null) { string operatorProperty = FilterSeverity.Split(':')[0]; validateCondition(operatorProperty, "FilterSeverity"); conditions.Add(new Condition( field: "severity", operatorProperty: FilterSeverity.Split(':')[0], values: FilterSeverity.Split(':')[1].Split(','))); conditionExist = true; } if (FilterMonitorService != null) { string operatorProperty = FilterMonitorService.Split(':')[0]; validateCondition(operatorProperty, "FilterMonitorService"); conditions.Add(new Condition( field: "MonitorService", operatorProperty: FilterMonitorService.Split(':')[0], values: FilterMonitorService.Split(':')[1].Split(','))); conditionExist = true; } if (FilterMonitorCondition != null) { string operatorProperty = FilterMonitorCondition.Split(':')[0]; validateCondition(operatorProperty, "FilterMonitorCondition"); conditions.Add(new Condition( field: "MonitorCondition", operatorProperty: FilterMonitorCondition.Split(':')[0], values: FilterMonitorCondition.Split(':')[1].Split(','))); conditionExist = true; } if (FilterTargetResourceType != null) { string operatorProperty = FilterTargetResourceType.Split(':')[0]; validateCondition(operatorProperty, "FilterTargetResourceType"); conditions.Add(new Condition( field: "TargetResourceType", operatorProperty: FilterTargetResourceType.Split(':')[0], values: FilterTargetResourceType.Split(':')[1].Split(','))); conditionExist = true; } if (FilterDescription != null) { string operatorProperty = FilterDescription.Split(':')[0]; validateCondition(operatorProperty, "FilterDescription"); conditions.Add(new Condition( field: "Description", operatorProperty: FilterDescription.Split(':')[0], values: FilterDescription.Split(':')[1].Split(','))); conditionExist = true; } if (FilterAlertRuleName != null) { string operatorProperty = FilterAlertRuleName.Split(':')[0]; validateCondition(operatorProperty, "FilterAlertRuleName"); conditions.Add(new Condition( field: "AlertRuleName", operatorProperty: FilterAlertRuleName.Split(':')[0], values: FilterAlertRuleName.Split(':')[1].Split(','))); conditionExist = true; } if (FilterAlertRuleId != null) { string operatorProperty = FilterAlertRuleId.Split(':')[0]; validateCondition(operatorProperty, "FilterAlertRuleId"); conditions.Add(new Condition( field: "AlertRuleId", operatorProperty: FilterAlertRuleId.Split(':')[0], values: FilterAlertRuleId.Split(':')[1].Split(','))); conditionExist = true; } if (FilterAlertContext != null) { string operatorProperty = FilterAlertContext.Split(':')[0]; validateCondition(operatorProperty, "FilterAlertContext"); conditions.Add(new Condition( field: "AlertContext", operatorProperty: FilterAlertContext.Split(':')[0], values: FilterAlertContext.Split(':')[1].Split(','))); conditionExist = true; } if (FilterSignalType != null) { string operatorProperty = FilterSignalType.Split(':')[0]; validateCondition(operatorProperty, "FilterSignalType"); conditions.Add(new Condition( field: "SignalType", operatorProperty: FilterSignalType.Split(':')[0], values: FilterSignalType.Split(':')[1].Split(','))); conditionExist = true; } if (conditionExist == true) { return(conditions); } return(null); }
public static Expression <Func <TEntity, bool> > BuildFilterExpression <TEntity>(FilterDescription filter) { var pattern = ParsePropertyValue(filter); return(BuildFilterExpression <TEntity>(pattern, filter.Field)); }
public static IQueryable <TEntity> Filter <TEntity>(this IQueryable <TEntity> toFilter, FilterDescription filter) { return(toFilter.Where(BuildFilterExpression <TEntity>(filter))); }
private static string GetLinqQueryString( FilterDescription filterDescription ) { string ret = ""; if ( !string.IsNullOrWhiteSpace( filterDescription.Filter ) ) { // using user str + linq.dynamic try { // xceed syntax : empty (contains), AND (uppercase), OR (uppercase), <>, * (end with), =, >, >=, <, <=, * (start with) // see http://doc.xceedsoft.com/products/XceedWpfDataGrid/Filter_Row.html // linq.dynamic syntax : =, ==, <>, !=, <, >, <=, >=, &&, and, ||, or, x.m(…) (where x is the attrib and m the function (ex: Contains, StartsWith, EndsWith ...) // see D:\DevC#\VirtualisingCollectionTest1\DynamicQuery\Dynamic Expressions.html // ex : RemoteOrDbDataSourceEmulation.Instance.Items.Where( "Name.Contains(\"e_1\") or Name.Contains(\"e_2\")" ); string exp = filterDescription.Filter; // arrange expression bool previousTermIsOperator = false; foreach ( Match match in _regexSplit.Matches( exp ) ) { if ( match.Success ) { //TODO processing results if ( _regexOp.IsMatch( match.Value ) ) { if ( _regexComparOp.IsMatch( match.Value ) ) { // simple operator >, <, ==, != ... ret += " " + filterDescription.PropertyName + " " + match.Value; previousTermIsOperator = true; } else { // and, or ... ret += " " + match.Value; previousTermIsOperator = false; } } else { // Value if ( previousTermIsOperator ) { ret += " " + match.Value; previousTermIsOperator = false; } else { if ( match.Value.StartsWith( "*" ) ) ret += " " + filterDescription.PropertyName + ".EndsWith( \"" + match.Value.Substring( 1 ) + "\" )"; else if ( match.Value.EndsWith( "*" ) ) ret += " " + filterDescription.PropertyName + ".StartsWith( \"" + match.Value.Substring( 0, match.Value.Length - 1 ) + "\" )"; else ret += " " + filterDescription.PropertyName + ".Contains( \"" + match.Value + "\" )"; previousTermIsOperator = false; } } } } } catch ( Exception ) {} } return ret; }