private static IEnumerable<IFilterDescriptor> GetChildDescriptors(IFilterDescriptor f)
{
if (f is CompositeFilterDescriptor)
{
return ((CompositeFilterDescriptor)f).FilterDescriptors;
}
return null;
}
private void InitilializeExpressionBuilderOptions(IFilterDescriptor filterDescriptor)
{
var descriptor = filterDescriptor as FilterDescriptorBase;
if (descriptor != null)
{
descriptor.ExpressionBuilderOptions.CopyFrom(this.Options);
}
}
public virtual Expression Visit(IFilterDescriptor filter)
{
if (filter is CompositeFilterDescriptor)
return VisitComposite(filter as CompositeFilterDescriptor);
else if (filter is FilterDescriptor)
return VisitBinary(filter as FilterDescriptor);
return Expression.Constant(true);
}
public static IDictionary<string, object> ApplyFilter(IFilterDescriptor filter)
{
IDictionary<string, object> parameters = new Dictionary<string, object>();
string filerMessage = string.Empty;
List<string> convertValue = new List<string>();
string filerOperators = string.Empty;
if (filter is CompositeFilterDescriptor)
{
foreach (IFilterDescriptor childFilter in ((CompositeFilterDescriptor)filter).FilterDescriptors)
{
parameters.SafeAdd(ApplyFilter(childFilter));
}
}
else
{
FilterDescriptor filterDescriptor = (FilterDescriptor)filter;
filerMessage = filterDescriptor.Member;
convertValue.Add(filterDescriptor.Value.ToSafeString());
switch (filterDescriptor.Operator)
{
case FilterOperator.IsEqualTo:
parameters.SafeAdd(filerMessage, filterDescriptor.Value);
break;
case FilterOperator.IsNotEqualTo:
parameters.SafeAdd(IdGenerator.NewComb().ToSafeString(), new Condition(string.Format("{0}<>'{1}'", filerMessage, filterDescriptor.Value)));
break;
case FilterOperator.StartsWith:
parameters.SafeAdd(IdGenerator.NewComb().ToSafeString(), new Condition(string.Format("{0} like '{1}%'", filerMessage, filterDescriptor.Value)));
break;
case FilterOperator.Contains:
parameters.SafeAdd(IdGenerator.NewComb().ToSafeString(), new Condition(string.Format("{0} like '%{1}%'", filerMessage, filterDescriptor.Value)));
break;
case FilterOperator.EndsWith:
parameters.SafeAdd(IdGenerator.NewComb().ToSafeString(), new Condition(string.Format("{0} like '%{1}'", filerMessage, filterDescriptor.Value)));
break;
case FilterOperator.IsLessThanOrEqualTo:
parameters.SafeAdd(IdGenerator.NewComb().ToSafeString(), new Condition(string.Format("{0} <='{1}'", filerMessage, filterDescriptor.Value)));
break;
case FilterOperator.IsLessThan:
parameters.SafeAdd(IdGenerator.NewComb().ToSafeString(), new Condition(string.Format("{0}<'{1}'", filerMessage, filterDescriptor.Value)));
break;
case FilterOperator.IsGreaterThanOrEqualTo:
parameters.SafeAdd(IdGenerator.NewComb().ToSafeString(), new Condition(string.Format("{0}>='{1}'", filerMessage, filterDescriptor.Value)));
break;
case FilterOperator.IsGreaterThan:
parameters.SafeAdd(IdGenerator.NewComb().ToSafeString(), new Condition(string.Format("{0}>'{1}'", filerMessage, filterDescriptor.Value)));
break;
}
}
return parameters;
}
/// <summary>
/// Preprocesses the filter descriptor.
/// </summary>
/// <param name="filterDescriptor">The filter descriptor.</param>
/// <param name="filterGuid">The filter unique identifier.</param>
/// <param name="processName">Name of the process.</param>
/// <param name="callback">The callback.</param>
public void PreprocessFilterDescriptor(IFilterDescriptor filterDescriptor, Guid filterGuid, string processName, Action<IFilterDescriptor> callback)
{
// request UPD parameters from User
var udpFilters = filterDescriptor.GetAllUdpDescriptors();
if (udpFilters != null && udpFilters.Count > 0)
{
UDPValuesViewModel.Value.Title = LanguageService.Translate("Label_ProvideFilterParams");
UDPValuesViewModel.Value.UdpList.Clear();
foreach (var filter in udpFilters)
{
UDPValuesViewModel.Value.UdpList.Add(FilterDescriptorDecorator.FromFilterDescriptor(filter));
var filterValue = filter.Value as FilterValue;
if (filterValue != null && filterValue.ProvidedValue == null)
{
filterValue.ProvidedValue = filterValue.DefaultValue;
}
}
FilteringUtils.LoadFilterAdditionalParameters(UDPValuesViewModel.Value.UdpList, processName, TheDynamicTypeManager);
ThePopupFactory.Value.Popup()
.SetCustomViewModel(UDPValuesViewModel.Value)
.SetIsModal(true)
.SetCaption(LanguageService.Translate("Label_FilterParameters"))
.SetPosition(PopupPosition.Center)
.Show(
() => callback(filterDescriptor),
() =>
{
callback(null);
return false;
});
}
else
{
callback(filterDescriptor);
}
}
public static string ApplyFilterExclude(IFilterDescriptor filter, string id, List <String> exclude)
{
var filters = string.Empty;
if (filter is CompositeFilterDescriptor)
{
filters += "(";
var compositeFilterDescriptor = (CompositeFilterDescriptor)filter;
foreach (IFilterDescriptor childFilter in compositeFilterDescriptor.FilterDescriptors)
{
filters += ApplyFilterExclude(childFilter, id, exclude);
filters += string.Format(" {0} ", compositeFilterDescriptor.LogicalOperator.ToString());
}
}
else
{
string filterDescriptor = String.Empty;
var descriptor = (FilterDescriptor)filter;
var filterMember = descriptor.Member;
var filterValue = descriptor.Value;
if (!exclude.Contains(descriptor.Member))
{
DateTime temp;
switch (descriptor.Operator)
{
case FilterOperator.IsEqualTo:
filterDescriptor += String.Format("{0} = N'{1}'", id + "[" + filterMember + "]", filterValue);
break;
case FilterOperator.IsNotEqualTo:
filterDescriptor += String.Format("{0} <> N'{1}'", id + "[" + filterMember + "]", filterValue);
break;
case FilterOperator.StartsWith:
filterDescriptor += String.Format("{0} like N'{1}%'", id + "[" + filterMember + "]", filterValue);
break;
case FilterOperator.Contains:
filterDescriptor += String.Format("{0} like N'%{1}%'", id + "[" + filterMember + "]", filterValue);
break;
case FilterOperator.EndsWith:
filterDescriptor += String.Format("{0} like N'%{1}'", id + "[" + filterMember + "]", filterValue);
break;
case FilterOperator.IsLessThanOrEqualTo:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0} <='{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0} <={1}", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsLessThan:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0}<'{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0}<{1}", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsGreaterThanOrEqualTo:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0}>='{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0}>={1}", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsGreaterThan:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0}>'{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0}>{1}", id + "[" + filterMember + "]", filterValue);
}
break;
}
}
else
{
filterDescriptor += "1=1";
}
filters = filterDescriptor;
}
filters = filters.EndsWith("And ") == true?string.Format("{0})", filters.Substring(0, filters.Length - 4)) : filters;
filters = filters.EndsWith("Or ") == true?string.Format("{0})", filters.Substring(0, filters.Length - 4)) : filters;
return(filters);
}
//add
public static Expression <Func <T, bool> > Expression <T>(IFilterDescriptor filterDescriptor)
{
return(Expression <T>(new IFilterDescriptor[] { filterDescriptor }));
}
/// <summary>
/// Convert a FilterDesriptor to a FilterExpression
/// </summary>
/// <param name="filterDescriptor"></param>
/// <returns></returns>
private static FilterExpression convert(IFilterDescriptor filterDescriptor)
{
FilterDescriptor fd = (FilterDescriptor)filterDescriptor;
switch (fd.Operator)
{
case FilterOperator.Contains:
{
return(new FilterStringItemExpression()
{
Field = new Field()
{
DataType = DataType.String, Name = fd.Member
}
,
Operator = StringOperator.Operation.Contains
,
Value = fd.Value
});
}
case FilterOperator.IsContainedIn:
{
return(new FilterStringItemExpression()
{
Field = new Field()
{
DataType = DataType.String, Name = fd.Member
}
,
Operator = StringOperator.Operation.Contains
,
Value = fd.Value
});
}
case FilterOperator.DoesNotContain:
{
return(null);
}
case FilterOperator.EndsWith:
{
return(new FilterStringItemExpression()
{
Field = new Field()
{
DataType = DataType.String, Name = fd.Member
}
,
Operator = StringOperator.Operation.EndsWith
,
Value = fd.Value
});
}
case FilterOperator.StartsWith:
{
return(new FilterStringItemExpression()
{
Field = new Field()
{
DataType = DataType.String, Name = fd.Member
}
,
Operator = StringOperator.Operation.StartsWith
,
Value = fd.Value
});
}
case FilterOperator.IsEqualTo:
{
return(new FilterStringItemExpression()
{
Field = new Field()
{
DataType = DataType.String, Name = fd.Member
}
,
Operator = StringOperator.Operation.Equals
,
Value = fd.Value
});
}
case FilterOperator.IsNotEqualTo:
{
return(null);
}
case FilterOperator.IsGreaterThan:
{
try
{
return(new FilterNumberItemExpression()
{
Field = new Field()
{
DataType = DataType.Ineteger, Name = fd.Member
}
,
Operator = NumberOperator.Operation.GreaterThan
,
Value = fd.Value
});
}
catch (Exception e)
{
throw new Exception("Value is not a number");
}
}
case FilterOperator.IsGreaterThanOrEqualTo:
{
try
{
return(new FilterNumberItemExpression()
{
Field = new Field()
{
DataType = DataType.Ineteger, Name = fd.Member
}
,
Operator = NumberOperator.Operation.GreaterThanOrEqual
,
Value = fd.Value
});
}
catch (Exception e)
{
throw new Exception("Value is not a number");
}
}
case FilterOperator.IsLessThan:
{
try
{
return(new FilterNumberItemExpression()
{
Field = new Field()
{
DataType = DataType.Ineteger, Name = fd.Member
}
,
Operator = NumberOperator.Operation.LessThan
,
Value = fd.Value
});
}
catch (Exception e)
{
throw new Exception("Value is not a number");
}
}
case FilterOperator.IsLessThanOrEqualTo:
{
try
{
return(new FilterNumberItemExpression()
{
Field = new Field()
{
DataType = DataType.Ineteger, Name = fd.Member
}
,
Operator = NumberOperator.Operation.LessThanOrEqual
,
Value = fd.Value
});
}
catch (Exception e)
{
throw new Exception("Value is not a number");
}
}
}
return(null);
}
/// <summary>
/// Populates the UDP.
/// </summary>
/// <param name="filterDef">The filter definition.</param>
private void PopulateUdp(string filterDef)
{
var filterDefinition = filterDef;
UdpList.Clear();
_processedFilter = FilterDescriptor.FromJSON(filterDefinition);
foreach (var filter in _processedFilter.GetAllUdpDescriptors())
{
var value = filter.Value as FilterValue;
if (value != null)
if (value.ProvidedValue == null)
value.ProvidedValue = value.DefaultValue;
var decorator = FilterDescriptorDecorator.FromFilterDescriptor(filter);
StartListenFilterValuePropertyChangedEvent(decorator);
UdpList.Add(decorator);
}
FilteringUtils.LoadFilterAdditionalParameters(UdpList, ProcessSystemName, TheDynamicTypeManager);
}
/// <summary>
/// Froms the filter descriptor.
/// </summary>
/// <param name="filterDescriptor">The filter descriptor.</param>
/// <returns>FilterDescriptorDecorator.</returns>
public static FilterDescriptorDecorator FromFilterDescriptor(IFilterDescriptor filterDescriptor)
{
return new FilterDescriptorDecorator(filterDescriptor);
}
private void OnFilterOptionsShowed(IFilterDescriptor filter)
{
var filterValue = filter.Value as FilterValue;
if (this.FilterOptionsVM.Value.IsStaticValue)
{
if (filterValue != null)
{
filterValue.ProvidedValue = this.FilterOptionsVM.Value.DefaultValue;
}
else
{
filter.Value = this.FilterOptionsVM.Value.DefaultValue;
}
}
else if (this.FilterOptionsVM.Value.IsSystemVariable)
{
if (this.FilterOptionsVM.Value.SelectedSystemVariable != null)
{
var val = FilterValue.CreateSystemVariable(this.FilterOptionsVM.Value.SelectedSystemVariable.Caption, this.FilterOptionsVM.Value.SelectedSystemVariable.Value);
if (filterValue != null)
{
filterValue.ProvidedValue = val;
}
else
{
filter.Value = val;
}
}
}
else if (this.FilterOptionsVM.Value.IsProcessField)
{
if (this.FilterOptionsVM.Value.SelectedProcessField != null)
{
var val = FilterValue.CreateProcessField(this.FilterOptionsVM.Value.SelectedProcessField.DisplayName, this.FilterOptionsVM.Value.SelectedProcessField.SystemName);
if (filterValue != null)
{
filterValue.ProvidedValue = val;
}
else
{
filter.Value = val;
}
}
}
this.ViewConfigurator.FilterDefinition = this.GetProcessedFilter().ToJSON();
}
private void PopulateUdp(string filterDef)
{
UdpList.Clear();
_processedFilter = FilterDescriptor.FromJSON(filterDef);
var udpFilters = _processedFilter.GetAllUdpDescriptors();
foreach (var filter in udpFilters)
{
// replace parameters to their default values
var value = filter.Value as FilterValue;
if (value != null)
{
if (value.ProvidedValue == null)
{
value.ProvidedValue = value.DefaultValue;
}
value.PropertyChanged += delegate
{
if (!_isLoading)
{
ViewConfigurator.FilterDefinition = GetProcessedFilter().ToJSON();
}
};
}
UdpList.Add(FilterDescriptorDecorator.FromFilterDescriptor(filter));
}
FilteringUtils.LoadFilterAdditionalParameters(UdpList, Parent.Model);
}
public string ApplyFilter(IFilterDescriptor filter)
{
return(ApplyFilter(filter, ""));
}
/// <summary>
/// Tries to create a filter descriptor that filters this field using the value returned by this mapping.
/// </summary>
/// <param name="sourceData">
/// The source data.
/// </param>
/// <param name="destination">
/// The destination.
/// </param>
/// <param name="filter">
/// The filter.
/// </param>
/// <returns>
/// <c>true</c> if the filter was created successfully; otherwise, <c>false</c>.
/// </returns>
public bool TryCreateFilter(DataTriggerSourceData sourceData, IEditableRoot destination, out IFilterDescriptor filter)
{
if (sourceData == null)
throw new ArgumentNullException("sourceData");
if (destination == null)
throw new ArgumentNullException("destination");
filter = null;
var value = GetValue(sourceData, destination, DefaultCultureName);
if (value != null && !DateTime.MinValue.Equals(value))
{
filter = new FilterDescriptor(FieldName, FilterOperator.IsEqualTo, value);
return true;
}
return false;
}
/// <summary>
/// Gets filters list.
/// </summary>
/// <param name="filterDescriptor">Filter's descriptor.</param>
/// <returns>Filters list.</returns>
private static List<FilterDescriptor> GetDescriptors(IFilterDescriptor filterDescriptor)
{
var descriptors = new List<FilterDescriptor>();
if (filterDescriptor.GetType() == typeof(FilterDescriptor))
{
descriptors.Add(filterDescriptor as FilterDescriptor);
}
else
{
foreach (IFilterDescriptor filter in (filterDescriptor as CompositeFilterDescriptor).FilterDescriptors)
{
descriptors.AddRange(GetDescriptors(filter));
}
}
return descriptors;
}
private static IFilterDescriptor AmendFilterValuesForSingleFilterDescriptor(IFilterDescriptor filterDescriptor)
{
IFilterDescriptor retVal = null;
var fItem = (filterDescriptor as FilterDescriptor);
var filterValObj = fItem.Value;
if (filterValObj != null && filterValObj.GetType() == typeof(string))
{
string filterVal = filterValObj.ToString().CorrectPersianChars();
(filterDescriptor as FilterDescriptor).Value = filterVal;
#region Geregorian Date
if (filterVal.EndsWith($"{_filterSeperator}dt"))
{
switch (fItem.Operator)
{
case FilterOperator.IsEqualTo:
retVal = getDateRangeCompositeFilterConditionForEquality(fItem, filterVal);
break;
case FilterOperator.IsGreaterThan:
getDateRangeCompositeFilterConditionForGreaterThan(fItem, filterVal);
break;
case FilterOperator.IsGreaterThanOrEqualTo:
getDateRangeCompositeFilterConditionForGreaterThanOrEqual(fItem, filterVal);
break;
case FilterOperator.IsLessThan:
getDateRangeCompositeFilterConditionForLessThan(fItem, filterVal);
break;
case FilterOperator.IsLessThanOrEqualTo:
getDateRangeCompositeFilterConditionForLessThanOrEqual(fItem, filterVal);
break;
case FilterOperator.IsNotEqualTo:
retVal = getDateRangeCompositeFilterConditionForInEquality(fItem, filterVal);
break;
default:
throw new NotImplementedException();
}
}
#endregion
#region persian Date
else if (filterVal.EndsWith($"{_filterSeperator}pdt"))
{
switch (fItem.Operator)
{
case FilterOperator.IsEqualTo:
GetPersianDateRangeFilterForEquality(fItem, filterVal);
break;
case FilterOperator.IsGreaterThan:
GetPersianDateRangeFilterForGreaterThan(fItem, filterVal);
break;
case FilterOperator.IsLessThan:
GetPersianDateRangeFilterForLessThan(fItem, filterVal);
break;
case FilterOperator.IsNotEqualTo:
GetPersiantDateRangeFilterForNotEquality(fItem, filterVal);
break;
default:
break;
}
}
#endregion
#region navigation property
else if (filterVal.Contains($"{_filterSeperator}nv"))
{
//TODO:
//1.Update both of "ConvertedValue" and "Value" Properties to the desired value from currently multi secion data of these fields.
//2.Update "Member" Property value.
retVal = new FilterDescriptor();
var newValue = fItem.ConvertedValue.ToString().Split(Convert.ToChar(_filterSeperator));
fItem.Member = newValue[1].Split(':')[1];
//fItem.ConvertedValue = newValue[0];
fItem.Value = newValue[0];
retVal = fItem;
}
#endregion
#region lookup and dropdownList
else if (filterVal.Contains($"{_filterSeperator}lkp") || filterVal.Contains($"{_filterSeperator}ddl") || filterVal.Contains($"{_filterSeperator}ac"))
{
retVal = new FilterDescriptor();
var newValue = fItem.ConvertedValue.ToString().Split(Convert.ToChar(_filterSeperator));
fItem.Member = newValue[1].Split(':')[1];
//fItem.ConvertedValue = newValue[0];
fItem.Value = newValue[0];
retVal = fItem;
}
#endregion
else
{
retVal = filterDescriptor;
}
}
else
{
retVal = filterDescriptor;
}
return(retVal);
}
/// <summary>
/// Executes the filter options.
/// </summary>
/// <param name="filter">The filter.</param>
private void ExecuteFilterOptions(IFilterDescriptor filter)
{
FilterOptionsVM.Value.CleanUp();
FilterOptionsVM.Value.ProcessFields = GetProcessFields(filter.MemberType);
FilterOptionsVM.Value.IsUdpEditMode = true;
FilterOptionsVM.Value.FilterDescriptor = filter;
FilterOptionsVM.Value.ShowUdPs = false;
FilterOptionsVM.Value.FilterFormatMemberType = new FilterFormatType { MemberType = filter.MemberType, FormatType = filter.FormatType };
ThePopupFactory.Popup()
.SetCustomViewModel(FilterOptionsVM.Value)
.SetIsModal(true)
.SetCaption(LanguageService.Translate("Msg_FilterOptions"))
.SetPosition(PopupPosition.Center)
.Show(() =>
{
var filterValue = filter.Value as FilterValue;
if (FilterOptionsVM.Value.IsStaticValue)
{
if (filterValue != null)
{
filterValue.ProvidedValue = FilterOptionsVM.Value.DefaultValue;
}
else
{
filter.Value = FilterOptionsVM.Value.DefaultValue;
}
}
else if (FilterOptionsVM.Value.IsSystemVariable)
{
if (FilterOptionsVM.Value.SelectedSystemVariable != null)
{
var val = FilterValue.CreateSystemVariable(FilterOptionsVM.Value.SelectedSystemVariable.Caption, FilterOptionsVM.Value.SelectedSystemVariable.Value);
if (filterValue != null)
{
filterValue.ProvidedValue = val;
}
else
{
filter.Value = val;
}
}
}
else if (FilterOptionsVM.Value.IsProcessField)
{
if (FilterOptionsVM.Value.SelectedProcessField != null)
{
var val = FilterValue.CreateProcessField(FilterOptionsVM.Value.SelectedProcessField.DisplayName, FilterOptionsVM.Value.SelectedProcessField.SystemName);
if (filterValue != null)
{
filterValue.ProvidedValue = val;
}
else
{
filter.Value = val;
}
}
}
StepModel.FilterDefinition = GetProcessedFilter().ToJSON();
});
}
/// <summary>
/// Loads process-dependent settings.
/// </summary>
/// <param name="settings">The settings.</param>
protected override void LoadProcessDependentSettings(IDictionary<string, string> settings)
{
base.LoadProcessDependentSettings(settings);
using (new AutoSaveSuppressor(this))
{
var filterMode = settings.ReadValue(SelectedFilterModeKey, string.Empty);
FilterType selectedFilterMode;
SelectedFilterMode = Enum.TryParse(filterMode, out selectedFilterMode) ? selectedFilterMode : FilterType.NoFilter;
var filterDefinition = settings.ReadValue(ProcessedFilterKey, string.Empty);
if (!string.IsNullOrWhiteSpace(filterDefinition))
_processedFilter = FilterDescriptor.FromJSON(filterDefinition);
var filter = settings.ReadValue(ChosenFilterKey, string.Empty);
if (CommonFilterList != null)
ChosenFilter = CommonFilterList.FirstOrDefault(x => x.Name == filter);
bool useDefaultLayout;
if (Boolean.TryParse(settings.ReadValue(UseDefaultLayoutKey, string.Empty), out useDefaultLayout))
{
UseDefaultLayout = useDefaultLayout;
}
if (!ShouldUseDefaultLayout() && LayoutList != null)
{
int layoutId;
if (Int32.TryParse(settings.ReadValue(SelectedLayoutKey, string.Empty), out layoutId))
{
SetSelectedLayout(LayoutList.FirstOrDefault(x => x.Id == layoutId));
}
int origLayoutId;
if (Int32.TryParse(settings.ReadValue(OriginalSelectedLayoutKey, string.Empty), out origLayoutId))
{
_originalSelectedLayout = LayoutList.FirstOrDefault(x => x.Id == origLayoutId);
}
}
if (SelectedLayout == null)
SetDefaultLayout();
SetupSubTitle();
if (SelectedTab != null)
SelectedTab.RefreshView();
}
}
public string ApplyFilter(IFilterDescriptor filter, string id)
{
var filters = string.Empty;
if (filter is CompositeFilterDescriptor)
{
filters += "(";
var compositeFilterDescriptor = (CompositeFilterDescriptor)filter;
foreach (IFilterDescriptor childFilter in compositeFilterDescriptor.FilterDescriptors)
{
filters += ApplyFilter(childFilter, id);
filters += string.Format(" {0} ", compositeFilterDescriptor.LogicalOperator.ToString());
}
}
else
{
string filterDescriptor = String.Empty;
var descriptor = (FilterDescriptor)filter;
string filterMember = descriptor.Member;
string filterValue = descriptor.Value.ToString().Replace("'", "''");
if (descriptor.Operator.ToString() == "IsContainedIn")
{
//string a = filterMember + " COLLATE Latin1_General_CS_AI ";
//filterMember = "dbo.fn_RemoveSignFromString(" + filterMember + ")";
filterMember = filterMember + " +'' COLLATE Latin1_General_CI_AI ";
filterValue = "(" + filterValue + ")";
}
if (descriptor.Operator.ToString() == "Contains")
{
//filterMember = "dbo.fn_RemoveSignFromString(" + filterMember + ")";
filterMember = filterMember + " +'' COLLATE Latin1_General_CI_AI ";
filterValue = "'%" + CustomModel.ConvertToUnsign(filterValue) + "%'";
}
DateTime temp;
switch (descriptor.Operator)
{
case FilterOperator.IsEqualTo:
filterDescriptor += String.Format("{0} = N'{1}'", id + "[" + filterMember + "]", filterValue);
break;
case FilterOperator.IsNotEqualTo:
filterDescriptor += String.Format("{0} <> N'{1}'", id + "[" + filterMember + "]", filterValue);
break;
case FilterOperator.StartsWith:
filterDescriptor += String.Format("{0} like N'{1}%'", id + "[" + filterMember + "]", filterValue);
break;
case FilterOperator.Contains:
//filterDescriptor += String.Format("{0} like N'%{1}%'", id + "[" + filterMember + "]", filterValue);
filterDescriptor += String.Format("{0} like {1}", id + filterMember, filterValue);
break;
case FilterOperator.IsContainedIn:
//filterDescriptor += String.Format("{0} like N'%{1}%'", id + "[" + filterMember + "]", filterValue);
filterDescriptor += String.Format("{0} in {1}", id + filterMember, filterValue);
break;
case FilterOperator.EndsWith:
filterDescriptor += String.Format("{0} like N'%{1}'", id + "[" + filterMember + "]", filterValue);
break;
case FilterOperator.IsLessThanOrEqualTo:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0} <='{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0} <={1}", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsLessThan:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0}<'{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0}<{1}", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsGreaterThanOrEqualTo:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0}>='{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0}>={1}", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsGreaterThan:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0}>'{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0}>{1}", id + "[" + filterMember + "]", filterValue);
}
break;
}
filters = filterDescriptor;
}
filters = filters.EndsWith("And ") == true?string.Format("{0})", filters.Substring(0, filters.Length - 4)) : filters;
filters = filters.EndsWith("Or ") == true?string.Format("{0})", filters.Substring(0, filters.Length - 4)) : filters;
return(filters);
}
private bool ReplaceGuidWithIdForStates(IFilterDescriptor descriptor)
{
var result = false;
if (descriptor.ColumnName == Constants.CurrentStateGuidColumnName)
{
var filterValue = descriptor.Value as FilterValue;
if (filterValue != null)
{
Guid guid;
if (filterValue.DefaultValue != null && Guid.TryParse(filterValue.DefaultValue.ToString(), out guid))
{
var state = this.ProcessCurrentStates.StateManager.States.FirstOrDefault(x => x.Guid == guid);
if (state != null)
{
descriptor.ReplaceDefaultValueFilterGuidWithId(state.Id);
return true;
}
}
}
}
if (descriptor.FilterDescriptors != null)
{
foreach (var fd in descriptor.FilterDescriptors)
{
result |= ReplaceGuidWithIdForStates(fd);
}
}
return result;
}
protected virtual void PopulateAsync(GenericViewModel <T> model, IFilterDescriptor filterDescriptor, IList <ISortDescriptor> sortDescriptors, IPagingRequest pagingRequest, Object[] contextInformation, ICache cache, Object localRequest)
{
lock (currentRequestLock)
{
// Early check here, but more important check in the finally-SyncContext.
// We will not update the ViewModel, if this request is not the current request (hence Populate was recalled
// since this request was initiated).
// An example where this is important would be a screen, where the user can enter search criteria and start
// a corresponding search, while the screen is still loading data from a preceeding request. In this case, the
// result of the second search could be retrieved before the first one, leading to wrong data in the screen.
//
// ToDo: Is there a scenario where the same VMDCC is used with multiple VMs or different Caches?
// If so, localRequest and currentRequest must contain the VM and Cache references to compare them!
if (!Object.ReferenceEquals(localRequest, currentRequest))
{
return;
}
}
IList <T> initialEntities = null;
IPagingResponse pagingResponse = null;
try
{
if (hasPagedViewModel)
{
pagingResponse = ((IPagingRefresher <T>)Refresher).Populate(filterDescriptor, sortDescriptors, pagingRequest, contextInformation);
initialEntities = new List <T>();
foreach (Object obj in pagingResponse.Result)
{
initialEntities.Add((T)obj);
}
}
else
{
if (filterDescriptor != null || sortDescriptors != null)
{
contextInformation = new Object[2];
contextInformation[0] = filterDescriptor;
contextInformation[1] = sortDescriptors;
}
initialEntities = ((IRefresher <T>)Refresher).Populate(contextInformation);
}
}
catch (Exception e)
{
if (Log.ErrorEnabled)
{
Log.Error(e);
}
}
finally
{
GuiThreadHelper.InvokeInGui(delegate()
{
lock (currentRequestLock)
{
if (!Object.ReferenceEquals(localRequest, currentRequest))
{
return;
}
}
try
{
if (IsRefreshedDataValid(contextInformation))
{
if (initialEntities != null)
{
if (ToBeCreatedOnTop)
{
// ToBeCreated entities are never part of the initialEntities, so no doublette check necessary
foreach (T entity in model.Objects)
{
if ((entity is IDataObject) && ((IDataObject)entity).ToBeCreated)
{
initialEntities.Insert(0, entity);
}
}
}
model.Clear();
for (int a = 0, size = initialEntities.Count; a < size; a++)
{
T item = initialEntities[a];
model.InsertAt(a, item);
}
}
// Important to update the sorting states (if the provider disables gridviews own sorting mechanism):
if (hasPagedViewModel)
{
UpdatePagingInformation(pagingResponse);
}
UpdateAfterDCE();
}
}
catch (Exception ex)
{
if (Log.ErrorEnabled)
{
Log.Error(ex);
}
}
finally
{
model.IsBusy = false;
}
});
}
}
private void ExecuteFilterOptions(IFilterDescriptor filter)
{
FilterOptionsVM.Value.CleanUp();
FilterOptionsVM.Value.ProcessFields = FilterExtensions.GetProcessFields(Parent.Model, filter.MemberType);
FilterOptionsVM.Value.IsUdpEditMode = true;
FilterOptionsVM.Value.FilterDescriptor = filter;
FilterOptionsVM.Value.ShowUdPs = false;
FilterOptionsVM.Value.ShowProcessFields = true;
ThePopupFactory.Popup()
.SetCustomViewModel(FilterOptionsVM.Value)
.SetIsModal(true)
.SetCaption(LanguageService.Translate("Msg_FilterOptions"))
.SetPosition(PopupPosition.Center)
.Show(() => this.OnFilterOptionsShowed(filter));
}
private void UpdateUdps()
{
using (UdpList.SuspendNotifications())
{
UdpList.Clear();
_processedFilter = null;
if (string.IsNullOrEmpty(FilterDefinition))
{
return;
}
var filterDef = FilterDefinition;
_processedFilter = FilterDescriptor.FromJSON(filterDef);
var udpFilters = _processedFilter.GetAllUdpDescriptors();
foreach (var filter in udpFilters)
{
// replace parameters to their default values
var value = filter.Value as FilterValue;
if (value != null)
{
if (value.ProvidedValue == null)
{
value.ProvidedValue = value.DefaultValue;
}
value.PropertyChanged += (sender, args) =>
{
try
{
SuppressUdpUpdate = true;
FilterDefinition = _processedFilter.ToJSON();
}
finally
{
SuppressUdpUpdate = false;
}
};
}
UdpList.Add(FilterDescriptorDecorator.FromFilterDescriptor(filter));
}
if (FilterSource != null)
{
FilterSource.UpdateParameters(UdpList);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FilterDescriptorDecorator"/> class.
/// </summary>
/// <param name="filterDescriptor">The filter descriptor.</param>
private FilterDescriptorDecorator(IFilterDescriptor filterDescriptor)
{
_innerFilterDescriptor = filterDescriptor;
}
/// <summary>
/// Updates the filter descriptor.
/// </summary>
/// <param name="filterDescriptor">
/// The filter.
/// </param>
/// <exception cref="ArgumentNullException">
/// The <paramref name="filterDescriptor"/> parameter is null.
/// </exception>
public void UpdateFilterDescriptor(IFilterDescriptor filterDescriptor)
{
if (filterDescriptor == null)
throw new ArgumentNullException("filterDescriptor");
var filterValue = filterDescriptor.Value as FilterValue;
if (IsStaticValue)
{
if (filterValue != null)
{
filterValue.ProvidedValue = DefaultValue;
}
else
{
filterDescriptor.Value = DefaultValue;
}
}
else if (IsSystemVariable)
{
if (SelectedSystemVariable != null)
{
var val = FilterValue.CreateSystemVariable(SelectedSystemVariable.Caption, SelectedSystemVariable.Value);
if (filterValue != null)
{
filterValue.ProvidedValue = val;
}
else
{
filterDescriptor.Value = val;
}
}
}
else if (IsProcessField)
{
if (SelectedProcessField != null)
{
var val = FilterValue.CreateProcessField(SelectedProcessField.DisplayName, SelectedProcessField.SystemName);
if (filterValue != null)
{
filterValue.ProvidedValue = val;
}
else
{
filterDescriptor.Value = val;
}
}
}
}
public virtual void DataChanged(IDataChange dataChange, DateTime dispatchTime, long sequenceId)
{
dataChange = dataChange.Derive(InterestedEntityTypes);
if (dataChange.IsEmpty)
{
return;
}
ISet <Object> directObjectsToDelete = null;
ISet <Type> requestedTypes = new HashSet <Type>();
IDictionary <Type, IEntityMetaData> typeToMetaDataDict = new Dictionary <Type, IEntityMetaData>();
GuiThreadHelper.InvokeInGuiAndWait(delegate()
{
IList <T> entities = Model.Objects;
for (int i = entities.Count; i-- > 0;)
{
Object entity = entities[i];
requestedTypes.Add(entity.GetType());
}
});
IList <IDataChangeEntry> dataChangeEntries = dataChange.Inserts;
for (int a = dataChangeEntries.Count; a-- > 0;)
{
requestedTypes.Add(dataChangeEntries[a].EntityType);
}
dataChangeEntries = dataChange.Updates;
for (int a = dataChangeEntries.Count; a-- > 0;)
{
requestedTypes.Add(dataChangeEntries[a].EntityType);
}
dataChangeEntries = dataChange.Deletes;
for (int a = dataChangeEntries.Count; a-- > 0;)
{
requestedTypes.Add(dataChangeEntries[a].EntityType);
}
IList <IEntityMetaData> metaDatas = EntityMetaDataProvider.GetMetaData(ListUtil.ToList(requestedTypes));
foreach (IEntityMetaData metaData in metaDatas)
{
typeToMetaDataDict[metaData.EntityType] = metaData;
}
bool consistsOnlyOfDirectDeletes = false;
if (dataChange.Deletes.Count > 0)
{
consistsOnlyOfDirectDeletes = true;
foreach (IDataChangeEntry deleteEntry in dataChange.Deletes)
{
if (deleteEntry is DirectDataChangeEntry)
{
if (directObjectsToDelete == null)
{
directObjectsToDelete = new IdentityHashSet <Object>();
}
directObjectsToDelete.Add(((DirectDataChangeEntry)deleteEntry).Entry);
}
else
{
consistsOnlyOfDirectDeletes = false;
}
}
}
IList <T> interestingEntities = null;
Object[] contextInformation = GetContextInformation();
IFilterDescriptor filterDescriptor = GetFilterDescriptor();
IList <ISortDescriptor> sortDescriptors = GetSortDescriptors();
IPagingRequest pagingRequest = GetPagingRequest();
IPagingResponse pagingResponse = null;
List <IDataChangeEntry> modifiedEntries = new List <IDataChangeEntry>();
modifiedEntries.AddRange(dataChange.All);
if (!consistsOnlyOfDirectDeletes)
{
interestingEntities = CacheContext.ExecuteWithCache(CacheProvider.GetCurrentCache(), delegate()
{
ConfigureCacheWithEagerLoads(Cache);
if (Refresher is IPagingRefresher <T> )
{
interestingEntities = new List <T>();
pagingResponse = ((IPagingRefresher <T>)Refresher).Refresh(modifiedEntries, filterDescriptor, sortDescriptors, pagingRequest, contextInformation);
foreach (Object obj in pagingResponse.Result)
{
interestingEntities.Add((T)obj);
}
return(interestingEntities);
}
else
{
if (filterDescriptor != null || sortDescriptors != null)
{
contextInformation = new Object[2];
contextInformation[0] = filterDescriptor;
contextInformation[1] = sortDescriptors;
}
return(((IRefresher <T>)Refresher).Refresh(modifiedEntries, contextInformation));
}
});
}
GuiThreadHelper.InvokeInGuiAndWait(delegate()
{
IList <T> entities = Model.Objects;
ISet <T> entitiesToAdd = null;
ISet <T> entitiesToRemove = null;
IDictionary <T, T> entitiesToReplace = null;
IDictionary <IObjRef, T> oldObjRefToOldEntityMap = null;
bool mergeModel = false;
if (interestingEntities != null && interestingEntities.Count > 0)
{
entitiesToAdd = new IdentityHashSet <T>(interestingEntities);
entitiesToRemove = new IdentityHashSet <T>(entities);
entitiesToReplace = new IdentityDictionary <T, T>();
oldObjRefToOldEntityMap = new Dictionary <IObjRef, T>();
mergeModel = true;
}
for (int i = entities.Count; i-- > 0;)
{
T oldEntity = entities[i];
if (directObjectsToDelete != null && directObjectsToDelete.Contains(oldEntity))
{
if (entitiesToRemove != null)
{
entitiesToRemove.Remove(oldEntity);
}
Model.RemoveAt(i);
continue;
}
Type oldEntityType = ProxyHelper.GetRealType(oldEntity.GetType());
PrimitiveMember idMember = typeToMetaDataDict[oldEntityType].IdMember;
Object oldEntityId = idMember.GetValue(oldEntity, false);
if (oldEntityId == null)
{
if (entitiesToRemove != null)
{
entitiesToRemove.Remove(oldEntity);
}
// Unpersisted object. This object should not be removed
// only because of a background DCE
continue;
}
bool entryRemoved = false;
foreach (IDataChangeEntry deleteEntry in dataChange.Deletes)
{
if (deleteEntry is DirectDataChangeEntry)
{
continue;
}
Object id = deleteEntry.Id;
if (!EqualsItems(oldEntityType, oldEntityId, deleteEntry.EntityType, id))
{
continue;
}
if (entitiesToRemove != null)
{
entitiesToRemove.Remove(oldEntity);
}
Model.RemoveAt(i);
entryRemoved = true;
break;
}
if (entryRemoved)
{
continue;
}
if (mergeModel)
{
IObjRef oldObjRef = new ObjRef(oldEntityType, ObjRef.PRIMARY_KEY_INDEX, oldEntityId, null);
T existingOldEntity = DictionaryExtension.ValueOrDefault(oldObjRefToOldEntityMap, oldObjRef);
if (existingOldEntity == null)
{
oldObjRefToOldEntityMap.Add(oldObjRef, oldEntity);
}
else if (!Object.ReferenceEquals(existingOldEntity, oldEntity))
{
// Force duplicate key exception
oldObjRefToOldEntityMap.Add(oldObjRef, oldEntity);
}
}
}
if (oldObjRefToOldEntityMap != null && oldObjRefToOldEntityMap.Count > 0)
{
IDictionary <IObjRef, T> newObjRefToNewEntityMap = new Dictionary <IObjRef, T>();
for (int a = interestingEntities.Count; a-- > 0;)
{
T newEntity = interestingEntities[a];
Type newEntityType = ProxyHelper.GetRealType(newEntity.GetType());
PrimitiveMember idMember = typeToMetaDataDict[newEntityType].IdMember;
Object newEntityId = idMember.GetValue(newEntity, false);
IObjRef newObjRef = new ObjRef(newEntityType, ObjRef.PRIMARY_KEY_INDEX, newEntityId, null);
newObjRefToNewEntityMap.Add(newObjRef, newEntity);
}
DictionaryExtension.Loop(oldObjRefToOldEntityMap, delegate(IObjRef objRef, T oldEntity)
{
T newEntity = DictionaryExtension.ValueOrDefault(newObjRefToNewEntityMap, objRef);
if (newEntity == null)
{
// Nothing to do if current oldEntity has no corresponding newEntity
return;
}
entitiesToAdd.Remove(newEntity);
if (!Object.ReferenceEquals(oldEntity, newEntity) &&
(dataChange.IsLocalSource || !(oldEntity is IDataObject) || !((IDataObject)oldEntity).ToBeUpdated))
{
entitiesToReplace[oldEntity] = newEntity;
}
entitiesToRemove.Remove(oldEntity);
});
}
if (mergeModel)
{
for (int a = entities.Count; a-- > 0;)
{
T item = entities[a];
if (entitiesToRemove.Contains(item))
{
Model.RemoveAt(a);
continue;
}
T replacingItem = DictionaryExtension.ValueOrDefault(entitiesToReplace, item);
if (replacingItem != null)
{
Model.Replace(a, replacingItem);
continue;
}
}
IEnumerator <T> enumerator = entitiesToAdd.GetEnumerator();
while (enumerator.MoveNext())
{
T entityToAdd = enumerator.Current;
Model.Add(entityToAdd);
}
if (hasPagedViewModel)
{
UpdatePagingInformation(pagingResponse);
}
UpdateAfterDCE();
}
});
}
/// <summary>
/// Updates the udps.
/// </summary>
private void UpdateUdps()
{
UdpList.Clear();
_processedFilter = null;
// if is No Filter - return, leave udpList empty
if (SelectedFilter == null || SelectedFilter.FilterGuid == Guid.Empty)
return;
PopulateUdp(SelectedFilter.Definition);
}
private void ExecuteFilterOptions(IFilterDescriptor filter)
{
FilterOptionsViewModel.CleanUp();
FilterOptionsViewModel.ProcessFields = FilteringProcess != null ? FilterExtensions.GetProcessFields(FilteringProcess, filter.MemberType) : null;
FilterOptionsViewModel.IsUdpEditMode = true;
FilterOptionsViewModel.FilterDescriptor = filter;
FilterOptionsViewModel.ShowUdPs = false;
FilterOptionsViewModel.ShowProcessFields = true;
PopupFactory.Popup()
.SetCustomViewModel(FilterOptionsViewModel)
.SetIsModal(true)
.SetCaption(LanguageService.Translate("Msg_FilterOptions"))
.SetPosition(PopupPosition.Center)
.Show(
() =>
{
var filterValue = filter.Value as FilterValue;
if (FilterOptionsViewModel.IsStaticValue)
{
if (filterValue != null)
{
filterValue.ProvidedValue = FilterOptionsViewModel.DefaultValue;
}
else
{
filter.Value = FilterOptionsViewModel.DefaultValue;
}
}
else if (FilterOptionsViewModel.IsSystemVariable)
{
if (FilterOptionsViewModel.SelectedSystemVariable == null)
{
return;
}
var val = FilterValue.CreateSystemVariable(
FilterOptionsViewModel.SelectedSystemVariable.Caption,
FilterOptionsViewModel.SelectedSystemVariable.Value);
if (filterValue != null)
{
filterValue.ProvidedValue = val;
}
else
{
filter.Value = val;
}
}
else if (FilterOptionsViewModel.IsProcessField)
{
if (FilterOptionsViewModel.SelectedProcessField == null)
{
return;
}
var val = FilterValue.CreateProcessField(
FilterOptionsViewModel.SelectedProcessField.DisplayName,
FilterOptionsViewModel.SelectedProcessField.SystemName);
if (filterValue != null)
{
filterValue.ProvidedValue = val;
}
else
{
filter.Value = val;
}
}
FilterDefinition = _processedFilter.ToJSON();
});
}
/// <summary>
/// Updates the udps.
/// </summary>
private void UpdateUdps()
{
UdpList.Clear();
_processedFilter = null;
if (SelectedFilter == null)
{
return;
}
PopulateUdp(FilterDefinition ?? SelectedFilter.Definition);
}
private IQueryable <TEntity> FilterExpression <TEntity>(IQueryable <TEntity> query, IFilterDescriptor filter)
where TEntity : class
{
try {
Expression <Func <TEntity, bool> > filterExpression = null;
if (filter is CompositeFilterDescriptor)
{
foreach (IFilterDescriptor childFilter in ((CompositeFilterDescriptor)filter).FilterDescriptors)
{
query = FilterExpression <TEntity>(query, childFilter);
}
}
else
{
FilterDescriptor filterDescriptor = (FilterDescriptor)filter;
ParameterExpression paramExp = Expression.Parameter(typeof(TEntity));
Expression exp = filterDescriptor.CreateFilterExpression(paramExp);
//MemberExpression fieldExp = Expression.PropertyOrField(paramExp, filterDescriptor.Member);
//ConstantExpression valueExp = Expression.Constant(filterDescriptor.Value, filterDescriptor.Value.GetType());
//Expression exp = null;
//if (fieldExp.Type == typeof(string))
//{
// MethodInfo method = typeof(string).GetMethod(filterDescriptor.Operator.ToString(), new[] { typeof(string) });
// exp = Expression.Call(fieldExp, method, valueExp);
//}
//else if (filterDescriptor.MemberType == typeof(int)
// || filterDescriptor.MemberType == typeof(long))
//{
// exp = Expression.LessThanOrEqual(fieldExp, valueExp);
//}
//else
//{
// exp = Expression.Equal(fieldExp, valueExp);
//}
filterExpression = Expression.Lambda <Func <TEntity, bool> >(exp, paramExp);
query = query.Where(filterExpression);
}
return(query);
}
catch (Exception ex) {
bool rethrow;
rethrow = DataExceptionHandler.HandleException(ref ex);
if (rethrow)
{
throw ex;
}
return(null);
}
}
/// <summary>
/// Clears the filters.
/// </summary>
private void ClearFilters()
{
_isLoading = true;
_processedFilter = null;
FilterDefinition = null;
UdpList.Clear();
Filters.Clear();
_isLoading = false;
}
/// <summary>
/// Executes the filter options.
/// </summary>
/// <param name="filter">The filter.</param>
private void ExecuteFilterOptions(IFilterDescriptor filter)
{
FilterOptionsVM.Value.CleanUp();
FilterOptionsVM.Value.IsUdpEditMode = true;
FilterOptionsVM.Value.FilterDescriptor = filter;
FilterOptionsVM.Value.ShowUdPs = false;
FilterOptionsVM.Value.ShowProcessFields = false;
FilterOptionsVM.Value.FilteringProcessSystemName = ((ProcessMetricsGadgetViewModel)base.Parent).ProcessSystemName;
FilterOptionsVM.Value.FilterFormatMemberType = new FilterFormatType { MemberType = filter.MemberType, FormatType = filter.FormatType };
ThePopupFactory.Popup().SetCustomViewModel(FilterOptionsVM.Value).SetIsModal(true).SetCaption(LanguageService.Translate("Label_FilterOptions")).SetPosition(PopupPosition.Center).Show(
() =>
{
var filterValue = filter.Value as FilterValue;
if (FilterOptionsVM.Value.IsStaticValue)
{
if (filterValue != null)
{
filterValue.ProvidedValue = FilterOptionsVM.Value.DefaultValue;
}
else
{
filter.Value = FilterOptionsVM.Value.DefaultValue;
}
}
else if (FilterOptionsVM.Value.IsSystemVariable)
{
if (FilterOptionsVM.Value.SelectedSystemVariable != null)
{
var val = FilterValue.CreateSystemVariable(FilterOptionsVM.Value.SelectedSystemVariable.Caption, FilterOptionsVM.Value.SelectedSystemVariable.Value);
if (filterValue != null)
{
filterValue.ProvidedValue = val;
}
else
{
filter.Value = val;
}
}
}
});
}
private IFilterDescriptor TransformFilterDescriptors(IFilterDescriptor filter)
{
if (filter is CompositeFilterDescriptor)
{
var compositeFilterDescriptor = filter as CompositeFilterDescriptor;
var transformedCompositeFilterDescriptor = new CompositeFilterDescriptor {
LogicalOperator = compositeFilterDescriptor.LogicalOperator
};
foreach (var filterDescriptor in compositeFilterDescriptor.FilterDescriptors)
{
transformedCompositeFilterDescriptor.FilterDescriptors.Add(TransformFilterDescriptors(filterDescriptor));
}
return(transformedCompositeFilterDescriptor);
}
if (filter is FilterDescriptor)
{
var filterDescriptor = filter as FilterDescriptor;
if (filterDescriptor.Value is DateTime)
{
var value = (DateTime)filterDescriptor.Value;
switch (filterDescriptor.Operator)
{
case FilterOperator.IsEqualTo:
//convert the "is equal to <date><time>" filter to a "is greater than or equal to <date> 00:00:00" AND "is less than or equal to <date> 23:59:59"
var isEqualCompositeFilterDescriptor = new CompositeFilterDescriptor {
LogicalOperator = FilterCompositionLogicalOperator.And
};
isEqualCompositeFilterDescriptor.FilterDescriptors.Add(new FilterDescriptor(filterDescriptor.Member,
FilterOperator.IsGreaterThanOrEqualTo, new DateTime(value.Year, value.Month, value.Day, 0, 0, 0)));
isEqualCompositeFilterDescriptor.FilterDescriptors.Add(new FilterDescriptor(filterDescriptor.Member,
FilterOperator.IsLessThanOrEqualTo, new DateTime(value.Year, value.Month, value.Day, 23, 59, 59)));
return(isEqualCompositeFilterDescriptor);
case FilterOperator.IsNotEqualTo:
//convert the "is not equal to <date><time>" filter to a "is less than <date> 00:00:00" OR "is greater than <date> 23:59:59"
var notEqualCompositeFilterDescriptor = new CompositeFilterDescriptor {
LogicalOperator = FilterCompositionLogicalOperator.Or
};
notEqualCompositeFilterDescriptor.FilterDescriptors.Add(new FilterDescriptor(filterDescriptor.Member,
FilterOperator.IsLessThan, new DateTime(value.Year, value.Month, value.Day, 0, 0, 0)));
notEqualCompositeFilterDescriptor.FilterDescriptors.Add(new FilterDescriptor(filterDescriptor.Member,
FilterOperator.IsGreaterThan, new DateTime(value.Year, value.Month, value.Day, 23, 59, 59)));
return(notEqualCompositeFilterDescriptor);
case FilterOperator.IsGreaterThanOrEqualTo:
//convert the "is greater than or equal to <date><time>" filter to a "is greater than or equal to <date> 00:00:00"
filterDescriptor.Value = new DateTime(value.Year, value.Month, value.Day, 0, 0, 0);
return(filterDescriptor);
case FilterOperator.IsGreaterThan:
//convert the "is greater than <date><time>" filter to a "is greater than <date> 23:59:59"
filterDescriptor.Value = new DateTime(value.Year, value.Month, value.Day, 23, 59, 59);
return(filterDescriptor);
case FilterOperator.IsLessThanOrEqualTo:
//convert the "is less than or equal to <date><time>" filter to a "is less than or equal to <date> 23:59:59"
filterDescriptor.Value = new DateTime(value.Year, value.Month, value.Day, 23, 59, 59);
return(filterDescriptor);
case FilterOperator.IsLessThan:
//convert the "is less than <date><time>" filter to a "is less than <date> 00:00:00"
filterDescriptor.Value = new DateTime(value.Year, value.Month, value.Day, 0, 0, 0);
return(filterDescriptor);
default:
throw new Exception(string.Format("Filter operator '{0}' is not supported for DateTime member '{1}'", filterDescriptor.Operator, filterDescriptor.Member));
}
}
}
return(filter);
}
/// <summary>
/// Tries to create a filter descriptor that filters this field using the value returned by this mapping.
/// </summary>
/// <param name="sourceData">
/// The source data.
/// </param>
/// <param name="destination">
/// The destination.
/// </param>
/// <param name="filter">
/// The filter.
/// </param>
/// <returns>
/// <c>true</c> if the filter was created successfully; otherwise, <c>false</c>.
/// </returns>
public bool TryCreateFilter(DataTriggerSourceData sourceData, IEditableRoot destination, out IFilterDescriptor filter)
{
throw new NotSupportedException();
}
private static List<IParameterBuilder> GetFilterParameters(IFilterDescriptor filter)
{
var parameterBuilders = new List<IParameterBuilder>();
if (filter == null)
return parameterBuilders;
var udpDescriptors = filter.GetAllUdpDescriptors();
foreach (var descriptor in udpDescriptors)
{
var filterValue = descriptor.Value as FilterValue;
if (filterValue == null || filterValue.ProvidedValue == null || (filterValue.ProvidedValue as FilterValue) == null)
continue;
var fieldName = ((FilterValue)filterValue.ProvidedValue).SystemName.TrimEnd("Id");
var fieldValue = "@" + fieldName;
parameterBuilders.Add(GenericParameterBuilder.CreateFromField(fieldValue, SqlDbType.Int, fieldName));
descriptor.Value = fieldValue;
descriptor.EscapeWildcards = false;
}
return parameterBuilders;
}
public static string ApplyFilter(IFilterDescriptor filter, string id)
{
var filters = string.Empty;
if (filter is CompositeFilterDescriptor)
{
filters += "(";
var compositeFilterDescriptor = (CompositeFilterDescriptor)filter;
foreach (IFilterDescriptor childFilter in compositeFilterDescriptor.FilterDescriptors)
{
filters += ApplyFilter(childFilter, id);
filters += string.Format(" {0} ", compositeFilterDescriptor.LogicalOperator.ToString());
}
}
else
{
string filterDescriptor = String.Empty;
var descriptor = (FilterDescriptor)filter;
var filterMember = descriptor.Member;
var filterValue = descriptor.Value.ToString().Replace("'", "''");
DateTime temp;
switch (descriptor.Operator)
{
case FilterOperator.IsEqualTo:
if (filterMember.Contains('.'))
{
filterDescriptor += String.Format("{0} = N'{1}'", id + filterMember, filterValue);
}
else
{
filterDescriptor += String.Format("{0} = N'{1}'", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsNotEqualTo:
if (filterMember.Contains('.'))
{
filterDescriptor += String.Format("{0} <> N'{1}'", id + filterMember, filterValue);
}
else
{
filterDescriptor += String.Format("{0} <> N'{1}'", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.StartsWith:
if (filterMember.Contains('.'))
{
filterDescriptor += String.Format("{0} COLLATE Latin1_General_CI_AI LIKE N'{1}%'", id + filterMember, filterValue);
}
else
{
filterDescriptor += String.Format("{0} COLLATE Latin1_General_CI_AI LIKE N'{1}%'", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.Contains:
if (filterMember.Contains('.'))
{
filterDescriptor += String.Format("{0} COLLATE Latin1_General_CI_AI LIKE N'%{1}%'", id + filterMember, filterValue);
}
else
{
filterDescriptor += String.Format("{0} COLLATE Latin1_General_CI_AI LIKE N'%{1}%'", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.EndsWith:
if (filterMember.Contains('.'))
{
filterDescriptor += String.Format("{0} COLLATE Latin1_General_CI_AI LIKE N'%{1}'", id + filterMember, filterValue);
}
else
{
filterDescriptor += String.Format("{0} COLLATE Latin1_General_CI_AI LIKE N'%{1}'", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsLessThanOrEqualTo:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0} <='{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0} <={1}", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsLessThan:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0}<'{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0}<{1}", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsGreaterThanOrEqualTo:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0}>='{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0}>={1}", id + "[" + filterMember + "]", filterValue);
}
break;
case FilterOperator.IsGreaterThan:
if (DateTime.TryParse(filterValue.ToString(), out temp))
{
filterDescriptor += String.Format("{0}>'{1}'", id + "[" + filterMember + "]", filterValue);
}
else
{
filterDescriptor += String.Format("{0}>{1}", id + "[" + filterMember + "]", filterValue);
}
break;
}
filters = filterDescriptor;
}
filters = filters.EndsWith("And ") == true?string.Format("{0})", filters.Substring(0, filters.Length - 4)) : filters;
filters = filters.EndsWith("Or ") == true?string.Format("{0})", filters.Substring(0, filters.Length - 4)) : filters;
return(filters);
}
private string GetFilter(IFilterDescriptor filter, string processName, string alias)
{
if (filter == null)
return string.Empty;
if (filter.FilterDescriptors == null)
{
PrepareFilter(processName, alias, filter);
}
else
{
foreach (IFilterDescriptor descriptor in filter.FilterDescriptors)
PrepareFilter(processName, alias, descriptor);
}
return AdoHelper.BuildFilterStatement(new List<IFilterDescriptor> { filter }, Process.Name);
}
private void PrepareFilter(string processName, string alias, IFilterDescriptor descriptor)
{
var columns = descriptor.GetColumns();
var table = processName;
var processType = Process.Repository.GetEditableRootType(table);
var n = 1;
var nAlias = alias;
foreach (var column in columns)
{
var fieldName = column.TrimEnd("Id");
var prop = processType.GetProperty(fieldName);
if (prop != null)
{
descriptor.ColumnName = string.Format(CultureInfo.InvariantCulture, "{0}.[{1}]", table.Equals(Constants.BasePersonProcessName) ? "p" : nAlias, fieldName);
continue;
}
var baseEdit = processType.GetProperty(Constants.BaseEditPropertyName);
while (baseEdit != null)
{
table = baseEdit.PropertyType.Name.TrimEnd("Edit");
processType = Process.Repository.GetEditableRootType(table);
nAlias = alias + n++;
prop = processType.GetProperty(fieldName);
if (prop != null)
{
descriptor.ColumnName = string.Format(CultureInfo.InvariantCulture, "{0}.[{1}]", table.Equals(Constants.BasePersonProcessName) ? "p" : nAlias, fieldName);
break;
}
baseEdit = processType.GetProperty(Constants.BaseEditPropertyName);
}
}
}
/// <summary>
/// Updates the udps.
/// </summary>
private void UpdateUdps()
{
UdpList.Clear();
_processedFilter = null;
if (ViewConfigurator == null || ViewConfigurator.FilterGuid == null)
{
return;
}
PopulateUdp(string.IsNullOrWhiteSpace(ViewConfigurator.FilterDefinition) ? FilterList.Where(x => x.GuidId == ViewConfigurator.FilterGuid).Select(x => x.FilterDefinition).FirstOrDefault() : ViewConfigurator.FilterDefinition);
}
public FilterDescriptorDecorator(IFilterDescriptor filterDescriptor)
{
if (filterDescriptor == null)
{
throw new ArgumentNullException("filterDescriptor");
}
ColumnName = filterDescriptor.ColumnName;
Operator = filterDescriptor.Operator;
Value = filterDescriptor.Value;
LogicalOperator = filterDescriptor.LogicalOperator;
FilterDescriptors = filterDescriptor.FilterDescriptors;
MemberType = filterDescriptor.MemberType;
FormatType = filterDescriptor.FormatType;
EscapeWildcards = filterDescriptor.EscapeWildcards;
}
/// <summary>
/// Clears the selected filter.
/// </summary>
private void ClearSelectedFilter()
{
Filter = null;
ChosenFilter = null;
SelectedFilter = string.Empty;
_processedFilter = null;
UdpList.Clear();
}
