public Expression <Func <TField, bool> > GetPredicate(Guid pageId, RelativeRoute relativeRoute)
{
var dataPredicate = _dataTypeMapper.GetPredicate(pageId, relativeRoute);
if (dataPredicate == null)
{
return(null);
}
var data = DataFacade.GetData <TDataType>(dataPredicate).Evaluate();
if (data.Count == 0)
{
return(null);
}
if (data.Count > 1)
{
throw new DataUrlCollisionException(typeof(TDataType), relativeRoute);
}
var keyObject = data.First().GetUniqueKey();
var key = ValueTypeConverter.Convert <TField>(keyObject);
var paramExpr = Expression.Parameter(typeof(TField));
var body = Expression.Equal(paramExpr, Expression.Constant(key));
return(Expression.Lambda <Func <TField, bool> >(body, paramExpr));
}
private IData TryDataByKeyProperty(PropertyUrlMapping propertyMapping, RelativeRoute keyRoutePart)
{
var method = StaticReflection.GetGenericMethodInfo(() => TryDataByKeyProperty <Guid>(null, null));
var genericMethod = method.MakeGenericMethod(propertyMapping.Property.PropertyType);
return(genericMethod.Invoke(this, new object[] { propertyMapping, keyRoutePart }) as TDataType);
}
public Expression <Func <TDataType, bool> > GetPredicate(Guid pageId, RelativeRoute route)
{
int segmentsProcessed = 0;
var segments = route.PathSegments;
var parameterExpression = Expression.Parameter(typeof(TDataType), "t");
Expression filterExpression = null;
foreach (var mapping in _mappings)
{
string[] segmentsArgument = null;
if (mapping.Mapper.PathSegmentsCount > 0)
{
segmentsArgument = segments.Skip(segmentsProcessed).Take(mapping.Mapper.PathSegmentsCount).ToArray();
segmentsProcessed += mapping.Mapper.PathSegmentsCount;
}
var relativeRoute = new RelativeRoute
{
PathSegments = segmentsArgument,
QueryString = route.QueryString
};
var fieldFilter = GetFieldFilter(mapping.Mapper, mapping.Property.PropertyType, pageId, relativeRoute);
if (fieldFilter == null)
{
return(null);
}
var propertyExpression = Expression.Property(parameterExpression, mapping.Property);
var filterFragmentExpression = Expression.Invoke(fieldFilter, propertyExpression);
filterExpression = filterExpression == null
? (Expression)filterFragmentExpression
: Expression.AndAlso(filterExpression, filterFragmentExpression);
}
if (filterExpression == null)
{
return(null);
}
if (typeof(IPageRelatedData).IsAssignableFrom(typeof(TDataType)))
{
var pageIdProperty = typeof(IPageRelatedData).GetProperty("PageId");
var propertyExpr = Expression.Property(parameterExpression, pageIdProperty);
var pageIdMatchExpr = Expression.Equal(propertyExpr, Expression.Constant(pageId));
filterExpression = Expression.AndAlso(pageIdMatchExpr, filterExpression);
}
return(Expression.Lambda <Func <TDataType, bool> >(filterExpression, parameterExpression));
}
private Expression GetFieldFilter(
IRelativeRouteToPredicateMapper mapper,
Type propertyType,
Guid pageId,
RelativeRoute relativeRoute)
{
var @interface = typeof(IRelativeRouteToPredicateMapper <>).MakeGenericType(propertyType);
return(@interface.GetMethod("GetPredicate").Invoke(mapper, new object[] { pageId, relativeRoute }) as Expression);
}
public Expression <Func <TValue, bool> > GetPredicate(Guid pageId, RelativeRoute routePart)
{
TValue fieldValue;
if (!TryGetValue(routePart, out fieldValue))
{
return(null);
}
return(field => field.Equals(fieldValue));
}
public Expression <Func <TValue, bool> > GetPredicate(Guid pageId, RelativeRoute route)
{
var stringValue = route.PathSegments.Single();
if (IsStringField)
{
return(field => field != null && StringToUrlPart(field as string) == stringValue);
}
var value = ValueTypeConverter.Convert <TValue>(stringValue);
return(field => field.Equals(value));
}
public IData TryGetData(Guid pageId, RelativeRoute routePart)
{
if (routePart.PathSegments.Length != PathSegmentsCount)
{
return(null);
}
// Searching by key, if key value is provided by mappers
if (_keyMapping != null)
{
var keyRoutePart = new RelativeRoute
{
PathSegments = routePart.PathSegments.Skip(_keyFieldUrlSegmentOffset)
.Take(_keyMapping.Mapper.PathSegmentsCount).ToArray(),
QueryString = routePart.QueryString
};
return(TryDataByKeyProperty(_keyMapping, keyRoutePart));
}
// Searching by a fields predicate otherwise
var predicate = GetPredicate(pageId, routePart);
if (predicate == null)
{
return(null);
}
var dataSet = DataFacade.GetData <TDataType>(predicate).Take(2).ToList();
if (dataSet.Count == 0)
{
return(null);
}
if (dataSet.Count > 1)
{
throw new DataUrlCollisionException(typeof(TDataType), routePart);
}
return(dataSet[0]);
}
public bool TryGetValue(RelativeRoute routePart, out TValue value)
{
var stringValue = routePart.PathSegments.Single();
if (string.IsNullOrEmpty(stringValue))
{
value = default(TValue);
return(false);
}
if (IsGuidField)
{
Guid tempGuid;
if (!UrlUtils.TryExpandGuid(stringValue, out tempGuid) && !Guid.TryParse(stringValue, out tempGuid))
{
value = default(TValue);
return(false);
}
value = (TValue)(tempGuid as object);
return(true);
}
if (IsStringField)
{
value = (TValue)(UrlUtils.DecodeUrlInvalidCharacters(stringValue) as object);
return(true);
}
Exception exception;
object valueObj = ValueTypeConverter.TryConvert(stringValue, typeof(TValue), out exception);
bool success = valueObj != null;
value = success ? (TValue)valueObj : default(TValue);
return(success);
}
public DataUrlCollisionException(Type dataType, RelativeRoute relativeRoute)
: base($"There are multiple data items of type '{dataType}' matching the same relative route '{relativeRoute}'")
{
}
private TDataType TryDataByKeyProperty <TKeyType>(PropertyUrlMapping propertyMapping, RelativeRoute keyRoutePart)
{
var valueProvider = propertyMapping.Mapper as IRelativeRouteValueProvider <TKeyType>;
if (valueProvider == null)
{
return(null);
}
TKeyType key;
if (!valueProvider.TryGetValue(keyRoutePart, out key))
{
return(null);
}
return(DataFacade.TryGetDataByUniqueKey(typeof(TDataType), key) as TDataType);
}
public DataUrlCollisionException(Type dataType, RelativeRoute relativeRoute)
: base($"There are multiple data items of type '{dataType}' matching the same relative route '{relativeRoute}'")
{
}
