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 FilterDescriptionExpressionBuilder(ParameterExpression parameterExpression, FilterDescription filterDescription) : base(parameterExpression)
{
this.filterDescription = filterDescription;
}
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;
}
