/// <summary>
/// Sets the filter descriptors.
/// </summary>
/// <param name="radDataFilter">The RAD data filter.</param>
/// <param name="filterDescriptor">The filter descriptor.</param>
public static void SetFilterDescriptors(this RadDataFilter radDataFilter, Veyron.SharedTypes.IFilterDescriptor filterDescriptor)
{
if (radDataFilter == null)
return;
// Deserialize CompositeFilterDescriptorCollection
var collection = filterDescriptor.GetFilterDescriptorCollection(radDataFilter);
if (radDataFilter.FilterDescriptors.Count > 0)
{
// First clear all filters on RadDataFilter
radDataFilter.FilterDescriptors.Clear();
}
// Set LogicalOperator
radDataFilter.FilterDescriptors.LogicalOperator = collection.LogicalOperator;
// Set filters
radDataFilter.FilterDescriptors.AddRange(collection);
}
/// <summary>
/// Adds new aggregate result to collection.
/// </summary>
/// <param name="group">The group.</param>
/// <param name="result">The aggregate result.</param>
/// <param name="func">The aggregate function.</param>
private static void AddAggregateResult(QueryableCollectionViewGroup group, Veyron.SharedTypes.AggregateResult result, AggregateFunction func)
{
var aggregateResult = new AggregateResult(result.Value, func);
var r = result;
var columnAggregates = group.AggregateResults
.SkipWhile(x => !x.FunctionName.StartsWith(r.ColumnName, StringComparison.Ordinal))
.TakeWhile(x => x.FunctionName.StartsWith(r.ColumnName, StringComparison.Ordinal))
.ToList();
if (!columnAggregates.Any())
group.AggregateResults.Add(aggregateResult);
else
{
var index = columnAggregates.TakeWhile(x =>
AggregateHelper.GetAttribute(
AggregateHelper.GetTypeByFullName(x.Caption.Replace(":", null))).Order <
AggregateHelper.GetAttribute(result.SummaryType).Order).Count();
if (columnAggregates.Count <= index)
{
var lastItemIndex = group.AggregateResults.IndexOf(columnAggregates.Last());
if (lastItemIndex == group.AggregateResults.Count - 1)
group.AggregateResults.Add(aggregateResult);
else
group.AggregateResults.Insert(lastItemIndex + 1, aggregateResult);
}
else
{
var itemIndex = group.AggregateResults.IndexOf(columnAggregates[index]);
group.AggregateResults.Insert(itemIndex, aggregateResult);
}
}
}
/// <summary>
/// Composites the filter descriptor.
/// </summary>
/// <param name="descriptor">The descriptor.</param>
/// <param name="result">The result.</param>
/// <param name="radDataFilter">The RAD data filter.</param>
private static void CompositeFilterDescriptor(Veyron.SharedTypes.IFilterDescriptor descriptor, ICompositeFilterDescriptor result, RadDataFilter radDataFilter)
{
foreach (var filter in descriptor.FilterDescriptors)
{
if (filter.FilterDescriptors == null || filter.FilterDescriptors.Count == 0)
result.FilterDescriptors.Add(GetRadFilterDescriptor(filter, radDataFilter));
else
{
var r = new CompositeFilterDescriptor
{
LogicalOperator = filter.LogicalOperator.ToRadLogicalOperator()
};
CompositeFilterDescriptor(filter, r, radDataFilter);
result.FilterDescriptors.Add(r);
}
}
}
private static FilterDescriptor GetRadFilterDescriptor(Veyron.SharedTypes.IFilterDescriptor descriptor, RadDataFilter radDataFilter)
{
var filterDescriptor = new FilterDescriptor
{
Member = descriptor.ColumnName,
Operator =
(Telerik.Windows.Data.FilterOperator)
Enum.Parse(typeof(Telerik.Windows.Data.FilterOperator), descriptor.Operator.ToString(), true)
};
var fieldValue = descriptor.Value as FilterValue;
if (fieldValue != null)
{
if (filterDescriptor.MemberType == typeof(string))
{
filterDescriptor.Value = fieldValue.ToString();
}
DynamicDataFilterBehavior.SetSystemValue(filterDescriptor, fieldValue);
}
else
{
DynamicDataFilterBehavior.SetSystemValue(filterDescriptor, null);
var itemDef = radDataFilter.ItemPropertyDefinitions.FirstOrDefault(x => x.PropertyName == filterDescriptor.Member);
if (itemDef != null)
{
if (itemDef.PropertyType == typeof(IStateInfo))
{
Guid stateGuid;
filterDescriptor.Value = Guid.TryParse(SafeTypeConverter.Convert<string>(descriptor.Value), out stateGuid)
? new StateInfoClass { Guid = stateGuid }
: new StateInfoClass { Id = SafeTypeConverter.Convert<int>(descriptor.Value) };
}
else
{
filterDescriptor.Value = itemDef.PropertyType == typeof(IInfoClass)
? new InfoClassPlaceholder(descriptor.Value)
: SafeTypeConverter.Convert(descriptor.Value, itemDef.PropertyType);
}
}
else
{
filterDescriptor.Value = descriptor.Value;
}
}
return filterDescriptor;
}
private void ResolveDependencies(Veyron.App app)
{
PaletteManager.ThemesJSon = "[]";
var loggerMock = Mock.Create<IClientLogger>();
var communicationServiceMock = Mock.Create<ICommunicationService>();
_authenticateServiceMock = Mock.Create<IAuthenticationService>();
Mock.Arrange(() => _authenticateServiceMock.Authenticate(Arg.IsAny<string>()))
.Returns((new TaskCompletionSource<object>()).Task);
var clientInfoMock = Mock.Create<IClientInfoService>();
_eventAggregatorMock = Mock.Create<IEventAggregator>();
var mainViewModelMock = Mock.Create<IShell>();
app.Logger = loggerMock;
app.CommunicationService = communicationServiceMock;
app.AuthenticationService = _authenticateServiceMock;
app.ClientInfoService = clientInfoMock;
app.TheEventAggregator = _eventAggregatorMock;
app.MainViewModel = mainViewModelMock;
}
