public static IDictionary <string, IFieldReader <TItem> > GetReaders <TItem>(this IFieldProvider <TItem> fieldProvider, [NotNull] IEnumerable <string> fieldNames)
where TItem : class
{
if (fieldProvider == null)
{
throw new ArgumentNullException(nameof(fieldProvider));
}
if (fieldNames == null)
{
throw new ArgumentNullException(nameof(fieldNames));
}
var dict = new Dictionary <string, IFieldReader <TItem> >();
foreach (string fieldName in fieldNames)
{
if (!fieldProvider.FieldExists(fieldName))
{
throw new FieldNotFoundException(fieldName, false);
}
IFieldReader <TItem> reader = fieldProvider.GetReader(fieldName);
if (reader == null)
{
throw new FieldOperationNotAllowedException(fieldName, FieldOperation.Read);
}
dict.Add(fieldName, reader);
}
return(dict);
}
private LambdaExpression GetOrderSelectorExpression(SortInstruction sortInstruction)
{
if (!_fieldProvider.FieldExists(sortInstruction.FieldName))
{
throw new FieldNotFoundException(sortInstruction.FieldName, false);
}
IFieldCollator <TItem> fieldCollator = _fieldProvider.GetCollator(sortInstruction.FieldName);
if (fieldCollator == null)
{
throw new FieldOperationNotAllowedException(sortInstruction.FieldName, FieldOperation.Sort);
}
try
{
ParameterExpression itemPram = Expression.Parameter(typeof(TItem), "srt");
LambdaExpression getterLambda = fieldCollator.GetSortExpression(itemPram);
if (getterLambda == null)
{
throw new NullReferenceException("No sort expression was defined for this field.");
}
return(getterLambda);
}
catch (Exception ex)
{
throw new FieldCannotFilterException(sortInstruction.FieldName, ex);
}
}
/// <remarks>
/// Ideas from https://stackoverflow.com/questions/5094489
/// </remarks>
private Expression <Func <TItem, bool> > GetFilterPredicateExpression(FilterInstruction filterInstruction)
{
if (!_fieldProvider.FieldExists(filterInstruction.FieldName))
{
throw new FieldNotFoundException(filterInstruction.FieldName, false);
}
IFieldCollator <TItem> fieldCollator = _fieldProvider.GetCollator(filterInstruction.FieldName);
if (fieldCollator == null)
{
throw new FieldOperationNotAllowedException(filterInstruction.FieldName, FieldOperation.Filter);
}
try
{
ParameterExpression itemPram = Expression.Parameter(typeof(TItem), "fltr");
Expression filterExpression = fieldCollator.GetFilterExpression(itemPram, filterInstruction.Operator, filterInstruction.ValueString);
if (filterExpression == null)
{
throw new ArgumentNullException(nameof(filterExpression), "No filter expression was defined for this field.");
}
Expression <Func <TItem, bool> > predicateLambda = Expression.Lambda <Func <TItem, bool> >(filterExpression, itemPram);
return(predicateLambda);
}
catch (Exception ex)
{
throw new FieldCannotFilterException(filterInstruction.FieldName, ex);
}
}
public async Task SetMappedValuesAsync([NotNull] IDeferredItem <TItem> deferredItem, [NotNull] RestItemData itemData)
{
foreach (KeyValuePair <string, object> kvp in itemData)
{
if (!_fieldProvider.FieldExists(kvp.Key))
{
throw new FieldNotFoundException(kvp.Key, false);
}
IFieldWriter <TItem> fieldWriter = _fieldProvider.GetWriter(kvp.Key);
if (fieldWriter == null)
{
throw new FieldOperationNotAllowedException(kvp.Key, FieldOperation.Write);
}
var namedField = new NamedField <TItem>(kvp.Key, _fieldProvider);
if (!_authChecker.CanEditField(deferredItem, namedField))
{
throw new NotAuthorizedForFieldException(AuthorizableVerb.Edit, kvp.Key);
}
await fieldWriter.SetValueAsync(deferredItem, kvp.Value, _dataTransaction);
}
}