public void Constructor_PopulatesFilterCollections()
{
// Arrange
IActionFilter expectedActionFilter = CreateDummyActionFilter();
IAuthorizationFilter expectedAuthorizationFilter = CreateDummyAuthorizationFilter();
IAuthenticationFilter expectedAuthenticationFilter = CreateDummyAuthenticationFilter();
IExceptionFilter expectedExceptionFilter = CreateDummyExceptionFilter();
IResultFilter expectedResultFilter = CreateDummyResultFilter();
List <Filter> filters = new List <Filter>()
{
CreateFilter(expectedActionFilter),
CreateFilter(expectedAuthorizationFilter),
CreateFilter(expectedAuthenticationFilter),
CreateFilter(expectedExceptionFilter),
CreateFilter(expectedResultFilter),
};
// Act
FilterInfo filterInfo = new FilterInfo(filters);
// Assert
Assert.Same(expectedActionFilter, filterInfo.ActionFilters.SingleOrDefault());
Assert.Same(expectedAuthorizationFilter, filterInfo.AuthorizationFilters.SingleOrDefault());
Assert.Same(expectedAuthenticationFilter, filterInfo.AuthenticationFilters.SingleOrDefault());
Assert.Same(expectedExceptionFilter, filterInfo.ExceptionFilters.SingleOrDefault());
Assert.Same(expectedResultFilter, filterInfo.ResultFilters.SingleOrDefault());
}
public void ResultFilters_ReturnsLastResultFilters_WhenOverrideScopeIsLast()
{
// Arrange
Filter firstFilter = CreateFilter(CreateDummyResultFilter(), FilterScope.First);
Filter globalFilter = CreateFilter(CreateDummyResultFilter(), FilterScope.Global);
Filter controllerFilter = CreateFilter(
CreateDummyResultFilter(),
FilterScope.Controller
);
Filter actionFilter = CreateFilter(CreateDummyResultFilter(), FilterScope.Action);
IResultFilter expectedLastFilter = CreateDummyResultFilter();
Filter lastFilter = CreateFilter(expectedLastFilter, FilterScope.Last);
Filter overrideFilter = CreateFilter(
CreateOverride(typeof(IResultFilter)),
FilterScope.Last
);
IEnumerable <Filter> filters = new Filter[]
{
firstFilter,
globalFilter,
controllerFilter,
actionFilter,
lastFilter,
overrideFilter
};
FilterInfo product = CreateProductUnderTest(filters);
// Act
IList <IResultFilter> resultFilters = product.ResultFilters;
// Assert
Assert.NotNull(resultFilters);
Assert.Equal(1, resultFilters.Count);
Assert.Same(expectedLastFilter, resultFilters[0]);
}
public T SearchWithCriteria(string index, ICriteria criteria, IResultFilter filter)
{
IHttpClientRequest request = CreateRequest(index, "POST", criteria.RawQuery, filter);
IHttpClientResponse <T> response = _client.Execute <T>(request);
return(response.ResponseData);
}
private ResultExecutedContext InvokeActionResultFilterRecursive(IList <IResultFilter> filters, int filterIndex, ResultExecutingContext preContext, ControllerContext controllerContext, ActionResult actionResult)
{
// Performance-sensitive
// For compatbility, the following behavior must be maintained
// The OnResultExecuting events must fire in forward order
// The InvokeActionResult must then fire
// The OnResultExecuted events must fire in reverse order
// Earlier filters can process the results and exceptions from the handling of later filters
// This is achieved by calling recursively and moving through the filter list forwards
// If there are no more filters to recurse over, create the main result
if (filterIndex > filters.Count - 1)
{
InvokeActionResult(controllerContext, actionResult);
return(new ResultExecutedContext(controllerContext, actionResult, canceled: false, exception: null));
}
// Otherwise process the filters recursively
IResultFilter filter = filters[filterIndex];
filter.OnResultExecuting(preContext);
if (preContext.Cancel)
{
return(new ResultExecutedContext(preContext, preContext.Result, canceled: true, exception: null));
}
bool wasError = false;
ResultExecutedContext postContext = null;
try
{
// Use the filters in forward direction
int nextFilterIndex = filterIndex + 1;
postContext = InvokeActionResultFilterRecursive(filters, nextFilterIndex, preContext, controllerContext, actionResult);
}
catch (ThreadAbortException)
{
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
postContext = new ResultExecutedContext(preContext, preContext.Result, canceled: false, exception: null);
filter.OnResultExecuted(postContext);
throw;
}
catch (Exception ex)
{
wasError = true;
postContext = new ResultExecutedContext(preContext, preContext.Result, canceled: false, exception: ex);
filter.OnResultExecuted(postContext);
if (!postContext.ExceptionHandled)
{
throw;
}
}
if (!wasError)
{
filter.OnResultExecuted(postContext);
}
return(postContext);
}
/// <summary>
/// Adds the result filter.
/// </summary>
/// <param name="filter">The filter.</param>
protected virtual void AddResultFilter(IResultFilter filter)
{
if (!ResultFilters.Contains(filter))
{
ResultFilters.Add(filter);
}
}
private static async Task ExecuteSyncFilter(
ResultExecutingContext context,
ResultExecutionDelegate next,
IResultFilter resultFilter)
{
resultFilter.OnResultExecuting(context);
if (!context.Cancel)
{
resultFilter.OnResultExecuted(await next());
}
}
public IEnumerable <IResultFilter> FiltersForQuery(TorznabQuery query)
{
IResultFilter filter = null;
if (!query.IsImdbQuery)
{
filter = new NoFilter();
}
else
{
filter = new ImdbTitleResultFilter(resolver, query);
}
return(filter.ToEnumerable());
}
public static void BeforeOnResultExecuting(
this DiagnosticListener diagnosticListener,
ResultExecutingContext resultExecutingContext,
IResultFilter filter)
{
Debug.Assert(diagnosticListener != null);
Debug.Assert(resultExecutingContext != null);
Debug.Assert(filter != null);
// Inlinable fast-path check if Diagnositcs is enabled
if (diagnosticListener.IsEnabled())
{
BeforeOnResultExecutingImpl(diagnosticListener, resultExecutingContext, filter);
}
}
public static void AfterOnResultExecuted(
this DiagnosticListener diagnosticListener,
ResultExecutedContext resultExecutedContext,
IResultFilter filter)
{
Debug.Assert(diagnosticListener != null);
Debug.Assert(resultExecutedContext != null);
Debug.Assert(filter != null);
// Inlinable fast-path check if diagnostic listener is enabled
if (diagnosticListener.IsEnabled())
{
AfterOnResultExecutedImpl(diagnosticListener, resultExecutedContext, filter);
}
}
private void SplitFilters(OverrideFilterInfo info)
{
Contract.Assert(info.Filters != null);
foreach (Filter filter in info.Filters)
{
Contract.Assert(filter != null);
IActionFilter actionFilter = filter.Instance as IActionFilter;
if (actionFilter != null && filter.Scope >= info.ActionOverrideScope)
{
_actionFilters.Add(actionFilter);
}
IAuthenticationFilter authenticationFilter =
filter.Instance as IAuthenticationFilter;
if (
authenticationFilter != null && filter.Scope >= info.AuthenticationOverrideScope
)
{
_authenticationFilters.Add(authenticationFilter);
}
IAuthorizationFilter authorizationFilter = filter.Instance as IAuthorizationFilter;
if (authorizationFilter != null && filter.Scope >= info.AuthorizationOverrideScope)
{
_authorizationFilters.Add(authorizationFilter);
}
IExceptionFilter exceptionFilter = filter.Instance as IExceptionFilter;
if (exceptionFilter != null && filter.Scope >= info.ExceptionOverrideScope)
{
_exceptionFilters.Add(exceptionFilter);
}
IResultFilter resultFilter = filter.Instance as IResultFilter;
if (resultFilter != null && filter.Scope >= info.ResultOverrideScope)
{
_resultFilters.Add(resultFilter);
}
}
}
public static void AfterOnResultExecuting(
this DiagnosticSource diagnosticSource,
ResultExecutingContext resultExecutingContext,
IResultFilter filter)
{
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterOnResultExecuting"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.AfterOnResultExecuting",
new
{
actionDescriptor = resultExecutingContext.ActionDescriptor,
resultExecutingContext = resultExecutingContext,
filter = filter
});
}
}
public override void OnResultExecuting(ResultExecutingContext filterContext)
{
base.OnResultExecuting(filterContext);
var jsonResult = filterContext.Result as JsonResult;
if (jsonResult == null)
{
return;
}
_queryType = jsonResult.Data.GetType().GetGenericArguments().LastOrDefault();
if (_queryType == null)
{
return;
}
_innerFilter = CreaterInnerFilter(_queryType);
_innerFilter.OnResultExecuting(filterContext);
}
public static void BeforeOnResultExecuted(
this DiagnosticSource diagnosticSource,
ActionDescriptor actionDescriptor,
ResultExecutedContext resultExecutedContext,
IResultFilter filter)
{
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeOnResultExecuted"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.BeforeOnResultExecuted",
new
{
actionDescriptor = actionDescriptor,
resultExecutedContext = resultExecutedContext,
filter = filter
});
}
}
void ProcessExceptionWhenInvokeActionResultFilter(IResultFilter filter, ResultExecutingContext preContext, Exception ex)
{
//Creating the context
var postContext = new ResultExecutedContext(preContext.Result, false /* canceled */, ex)
{
Controller = preContext.Controller,
ActionParameters = preContext.ActionParameters,
ActionMethod = _actionMethod
};
filter.OnResultExecuted(postContext);
//If the exception is !handled we throw it
if (!postContext.ExceptionHandled)
{
throw ex;
}
}
private static ResultExecutedContext InvokeActionResultFilter(IResultFilter filter,
ResultExecutionContext context, Func <ResultExecutedContext> continuation)
{
filter.OnResultExecuting(context);
if (context.Cancel)
{
return(new ResultExecutedContext(context, null));
}
bool wasError = false;
ResultExecutedContext postContext = null;
try
{
postContext = continuation();
}
catch (ThreadAbortException)
{
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
postContext = new ResultExecutedContext(context, null);
filter.OnResultExecuted(postContext);
throw;
}
catch (Exception ex)
{
wasError = true;
postContext = new ResultExecutedContext(context, ex);
filter.OnResultExecuted(postContext);
if (!postContext.ExceptionHandled)
{
throw;
}
}
if (!wasError)
{
filter.OnResultExecuted(postContext);
}
return(postContext);
}
/// <summary>
/// Execute the prefilter result, the actionResult and the postfilter result
/// </summary>
/// <param name="filter">The result filter</param>
/// <param name="preContext">The builded preContext</param>
/// <param name="continuation">The lambda expression wich execute the actionResult and the post filter result attribute</param>
/// <returns>The result of the execution of the post filter result attribute</returns>
ResultExecutedContext InvokeActionResultFilter(IResultFilter filter, ResultExecutingContext preContext, Delegates.Func <ResultExecutedContext> continuation)
{
//Executing the filter
filter.OnResultExecuting(preContext);
//If the execution is cancelled
if (preContext.Cancel)
{
return(new ResultExecutedContext(preContext.Result, true /* canceled */, null /* exception */)
{
Controller = preContext.Controller,
ActionParameters = preContext.ActionParameters,
ActionMethod = _actionMethod
});
}
bool wasError = false;
ResultExecutedContext postContext = null;
try
{
//Creating the ResultExecutedContext by executing the actionResult
postContext = continuation();
}
catch (TargetInvocationException ex)
{
wasError = true;
ProcessExceptionWhenInvokeActionResultFilter(filter, preContext, ex.InnerException ?? ex);
}
catch (Exception ex)
{
wasError = true;
ProcessExceptionWhenInvokeActionResultFilter(filter, preContext, ex);
}
//Everything is executed well
if (!wasError)
{
filter.OnResultExecuted(postContext);
}
return(postContext);
}
/// <summary>
/// Execute the prefilter result, the actionResult and the postfilter result
/// </summary>
/// <param name="filter">The result filter</param>
/// <param name="preContext">The builded preContext</param>
/// <param name="continuation">The lambda expression wich execute the actionResult and the post filter result attribute</param>
/// <returns>The result of the execution of the post filter result attribute</returns>
private ResultExecutedContext InvokeActionResultFilter(IResultFilter filter, ResultExecutingContext preContext, Func <ResultExecutedContext> continuation)
{
//Executing the filter
filter.OnResultExecuting(preContext);
//If the execution is cancelled
if (preContext.Cancel)
{
return(new ResultExecutedContext(preContext.Controller, preContext.Result, true /* canceled */, null /* exception */));
}
bool wasError = false;
ResultExecutedContext postContext = null;
try
{
//Creating the ResultExecutedContext by executing the actionResult
postContext = continuation();
}
catch (Exception ex)
{
wasError = true;
//Creating the context
postContext = new ResultExecutedContext(preContext.Controller, preContext.Result, false /* canceled */, ex);
filter.OnResultExecuted(postContext);
//If the exception is !handled we throw it
if (!postContext.ExceptionHandled)
{
throw;
}
}
//Everything is executed well
if (!wasError)
{
filter.OnResultExecuted(postContext);
}
return(postContext);
}
public static void AfterOnResultExecuted(
this DiagnosticSource diagnosticSource,
ResultExecutedContext resultExecutedContext,
IResultFilter filter)
{
Debug.Assert(diagnosticSource != null);
Debug.Assert(resultExecutedContext != null);
Debug.Assert(filter != null);
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterOnResultExecuted"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.AfterOnResultExecuted",
new
{
actionDescriptor = resultExecutedContext.ActionDescriptor,
resultExecutedContext = resultExecutedContext,
filter = filter
});
}
}
internal static ModuleResultExecutedContext InvokeActionResultFilter(IResultFilter filter, ResultExecutingContext preContext, Func <ModuleResultExecutedContext> continuation)
{
filter.OnResultExecuting(preContext);
if (preContext.Cancel)
{
return(new ModuleResultExecutedContext(preContext, preContext.Result, true /* canceled */, null /* exception */, ""));
}
bool wasError = false;
ModuleResultExecutedContext postContext = null;
try
{
postContext = continuation();
}
catch (ThreadAbortException)
{
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
postContext = new ModuleResultExecutedContext(preContext, preContext.Result, false /* canceled */, null /* exception */, "");
filter.OnResultExecuted(postContext);
throw;
}
catch (Exception ex)
{
wasError = true;
postContext = new ModuleResultExecutedContext(preContext, preContext.Result, false /* canceled */, ex, "");
filter.OnResultExecuted(postContext);
if (!postContext.ExceptionHandled)
{
throw;
}
}
if (!wasError)
{
filter.OnResultExecuted(postContext);
}
return(postContext);
}
/// <summary>
/// 执行请求结果的筛选器
/// </summary>
/// <param name="filter"></param>
/// <param name="preContext"></param>
/// <param name="continuation"></param>
/// <returns></returns>
internal static ResultExecutedContext InvokeActionResultFilter(IResultFilter filter, ResultExecutingContext preContext, Func <ResultExecutedContext> continuation)
{
filter.OnResultExecuting(preContext);
if (preContext.Cancel)
{
return(new ResultExecutedContext(preContext, preContext.Result, true, null));
}
bool flag = false;
ResultExecutedContext resultExecutedContext = null;
try
{
resultExecutedContext = continuation();
}
catch (ThreadAbortException)
{
resultExecutedContext = new ResultExecutedContext(preContext, preContext.Result, false, null);
filter.OnResultExecuted(resultExecutedContext);
throw;
}
catch (Exception exception)
{
flag = true;
resultExecutedContext = new ResultExecutedContext(preContext, preContext.Result, false, exception);
filter.OnResultExecuted(resultExecutedContext);
if (!resultExecutedContext.ExceptionHandled)
{
throw;
}
}
if (!flag)
{
filter.OnResultExecuted(resultExecutedContext);
}
return(resultExecutedContext);
}
protected virtual IHttpClientRequest CreateRequest(string indexName, string method, object criteria, IResultFilter filter)
{
IHttpClientRequest request = new HttpClientRequest
{
Path = $"/v1/search/{indexName ?? _defautIndexName}",
ContentType = "application/json",
Method = method,
Authenticaton = _auth,
Body = criteria
};
return(CreateQueryParameters(request, filter, null)); //TODO qtName
}
protected virtual IHttpClientRequest CreateQueryParameters(IHttpClientRequest request, IResultFilter filter, string qtName)
{
if (qtName != null)
{
request.QueryParameters.Add(new KeyValuePair <string, object>(QueryConstants.ResultModel, qtName));
}
if (filter == null)
{
return(request);
}
if (filter.ExcludeFields != null && filter.ExcludeFields.Count > 0)
{
request.QueryParameters.Add(QueryConstants.ExcludeFields, string.Join(",", filter.ExcludeFields.Select(x => x)));
}
if (filter.StartOfRange.HasValue)
{
request.QueryParameters.Add(QueryConstants.StartRange, filter.StartOfRange.Value);
}
if (filter.EndOfRange.HasValue)
{
request.QueryParameters.Add(QueryConstants.EndRange, filter.EndOfRange.Value);
}
if (filter.MaxResults.HasValue)
{
request.QueryParameters.Add(QueryConstants.MaxResults, filter.MaxResults.Value);
}
request.QueryParameters.Add(QueryConstants.Highlighting, filter.IsHighlightingEnabled);
request.QueryParameters.Add(QueryConstants.HighlightInAll, filter.IsHighlightInAllEnabled);
return(request);
}
public static void AfterOnResultExecuted(
this DiagnosticSource diagnosticSource,
ActionDescriptor actionDescriptor,
ResultExecutedContext resultExecutedContext,
IResultFilter filter)
{
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterOnResultExecuted"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.AfterOnResultExecuted",
new
{
actionDescriptor = actionDescriptor,
resultExecutedContext = resultExecutedContext,
filter = filter
});
}
}
public static void BeforeOnResultExecuting(
this DiagnosticSource diagnosticSource,
ResultExecutingContext resultExecutingContext,
IResultFilter filter)
{
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeOnResultExecuting"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.BeforeOnResultExecuting",
new
{
actionDescriptor = resultExecutingContext.ActionDescriptor,
resultExecutingContext = resultExecutingContext,
filter = filter
});
}
}
private static void AfterOnResultExecutedImpl(DiagnosticListener diagnosticListener, ResultExecutedContext resultExecutedContext, IResultFilter filter)
{
if (diagnosticListener.IsEnabled("Microsoft.AspNetCore.Mvc.AfterOnResultExecuted"))
{
diagnosticListener.Write(
"Microsoft.AspNetCore.Mvc.AfterOnResultExecuted",
new
{
actionDescriptor = resultExecutedContext.ActionDescriptor,
resultExecutedContext = resultExecutedContext,
filter = filter
});
}
}
public virtual async Task <T> SearchWithCriteriaAsync(string index, ICriteria criteria, IResultFilter filter, CancellationToken cancellationToken = default(CancellationToken))
{
IHttpClientRequest request = CreateRequest(index, "POST", criteria.RawQuery, filter);
IHttpClientResponse <T> response = await _client.ExecuteAsync <T>(request, cancellationToken).ConfigureAwait(false);
return(response.ResponseData);
}
internal static ResultExecutedContext InvokeActionResultFilter(IResultFilter filter, ResultExecutingContext preContext, Func<ResultExecutedContext> continuation)
{
filter.OnResultExecuting(preContext);
if (preContext.Cancel)
{
return new ResultExecutedContext(preContext, preContext.Result, true /* canceled */, null /* exception */);
}
bool wasError = false;
ResultExecutedContext postContext = null;
try
{
postContext = continuation();
}
catch (ThreadAbortException)
{
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
postContext = new ResultExecutedContext(preContext, preContext.Result, false /* canceled */, null /* exception */);
filter.OnResultExecuted(postContext);
throw;
}
catch (Exception ex)
{
wasError = true;
postContext = new ResultExecutedContext(preContext, preContext.Result, false /* canceled */, ex);
filter.OnResultExecuted(postContext);
if (!postContext.ExceptionHandled)
{
throw;
}
}
if (!wasError)
{
filter.OnResultExecuted(postContext);
}
return postContext;
}
public ResultFilterOverride(IResultFilter wrappedFilter)
{
this._wrappedFilter = wrappedFilter;
}
/// <summary>
/// Adds the specified filter to the ResultFilter list.
/// </summary>
/// <param name="filter"></param>
protected virtual void AddResultFilter(IResultFilter filter)
{
if (ResultFilters.Contains(filter)) return;
ResultFilters.Add(filter);
}
public GlimpseResultFilter(IResultFilter resultFilter)
{
ResultFilter = resultFilter;
}
public void Add(IResultFilter filter, int?order = null)
{
Add(filter, order);
}
private static ResultExecutedContext InvokeActionResultFilter(IResultFilter filter,
ResultExecutionContext context, Func<ResultExecutedContext> continuation)
{
filter.OnResultExecuting(context);
if (context.Cancel)
return new ResultExecutedContext(context, null);
bool wasError = false;
ResultExecutedContext postContext = null;
try
{
postContext = continuation();
}
catch (ThreadAbortException)
{
// This type of exception occurs as a result of Response.Redirect(), but we special-case so that
// the filters don't see this as an error.
postContext = new ResultExecutedContext(context, null);
filter.OnResultExecuted(postContext);
throw;
}
catch (Exception ex)
{
wasError = true;
postContext = new ResultExecutedContext(context, ex);
filter.OnResultExecuted(postContext);
if (!postContext.ExceptionHandled)
throw;
}
if (!wasError)
filter.OnResultExecuted(postContext);
return postContext;
}
private static void BeforeOnResultExecutingImpl(DiagnosticListener diagnosticListener, ResultExecutingContext resultExecutingContext, IResultFilter filter)
{
if (diagnosticListener.IsEnabled(Diagnostics.BeforeResultFilterOnResultExecutingEventData.EventName))
{
diagnosticListener.Write(
Diagnostics.BeforeResultFilterOnResultExecutingEventData.EventName,
new BeforeResultFilterOnResultExecutingEventData(
resultExecutingContext.ActionDescriptor,
resultExecutingContext,
filter
));
}
}
public ResultFilterOverride(IResultFilter wrappedFilter)
{
_wrappedFilter = wrappedFilter;
}
private static void AfterOnResultExecutedImpl(DiagnosticListener diagnosticListener, ResultExecutedContext resultExecutedContext, IResultFilter filter)
{
if (diagnosticListener.IsEnabled(Diagnostics.AfterResultFilterOnResultExecutedEventData.EventName))
{
diagnosticListener.Write(
Diagnostics.AfterResultFilterOnResultExecutedEventData.EventName,
new AfterResultFilterOnResultExecutedEventData(
resultExecutedContext.ActionDescriptor,
resultExecutedContext,
filter
));
}
}
public GlimpseResultFilter(IResultFilter resultFilter)
{
ResultFilter = resultFilter;
}
public ISearcherApi <T, R> WithResultFilter(IResultFilter filter)
{
ResultFilter = filter;
return(this);
}
public static void BeforeOnResultExecuted(
this DiagnosticSource diagnosticSource,
ResultExecutedContext resultExecutedContext,
IResultFilter filter)
{
Debug.Assert(diagnosticSource != null);
Debug.Assert(resultExecutedContext != null);
Debug.Assert(filter != null);
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeOnResultExecuted"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.BeforeOnResultExecuted",
new
{
actionDescriptor = resultExecutedContext.ActionDescriptor,
resultExecutedContext = resultExecutedContext,
filter = filter
});
}
}
