protected virtual void SetNoCache(ResultExecutingContext context)
{
//Based on http://stackoverflow.com/questions/49547/making-sure-a-web-page-is-not-cached-across-all-browsers
context.HttpContext.Response.Headers["Cache-Control"] = "no-cache, no-store, must-revalidate, max-age=0";
context.HttpContext.Response.Headers["Pragma"] = "no-cache";
context.HttpContext.Response.Headers["Expires"] = "0";
}
public override void OnResultExecuting(ResultExecutingContext context)
{
var result = context.Result;
if (result is ViewResult)
{
if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Type-Options"))
{
context.HttpContext.Response.Headers.Add("X-Content-Type-Options", "nosniff");
}
if (!context.HttpContext.Response.Headers.ContainsKey("X-Frame-Options"))
{
context.HttpContext.Response.Headers.Add("X-Frame-Options", "SAMEORIGIN");
}
var csp = "default-src 'self'";
// once for standards compliant browsers
if (!context.HttpContext.Response.Headers.ContainsKey("Content-Security-Policy"))
{
context.HttpContext.Response.Headers.Add("Content-Security-Policy", csp);
}
// and once again for IE
if (!context.HttpContext.Response.Headers.ContainsKey("X-Content-Security-Policy"))
{
context.HttpContext.Response.Headers.Add("X-Content-Security-Policy", csp);
}
}
}
public void OnResultExecuting(ResultExecutingContext context)
{
var headerName = "OnResultExecuting";
context.HttpContext.Response.Headers.Add(
headerName, new string[] { "ResultExecutingSuccessfully" });
_logger.LogInformation($"Header added: {headerName}");
}
public void OnResultExecuting(ResultExecutingContext filterContext)
{
// Should only run on a full view rendering result
if (!(filterContext.Result is ViewResult))
{
return;
}
// Should only run on the Admin
if (!AdminAttribute.IsApplied(filterContext.HttpContext))
{
return;
}
// Populate main nav
IShape menuShape = _shapeFactory.Create("Menu",
Arguments.From(new
{
MenuName = "admin",
RouteData = filterContext.RouteData,
}));
// Enable shape caching
menuShape.Metadata
.Cache("menu-admin")
.AddContext("user.roles")
.AddDependency("features")
.AddDependency("types") // This should go in a Displaying Shape event in the Contents module
;
_layoutAccessor.GetLayout().Navigation.Add(menuShape);
}
public override void OnResultExecuting(ResultExecutingContext context)
{
context.HttpContext.Response.Headers["Cache-Control"] = "no-cache, no-store, max-age=0";
context.HttpContext.Response.Headers["Pragma"] = "no-cache";
context.HttpContext.Response.Headers["Expires"] = "-1";
base.OnResultExecuting(context);
}
public override void OnResultExecuting(ResultExecutingContext context)
{
var objResult = context.Result as ObjectResult;
var dummyClass = objResult.Value as DummyClass;
dummyClass.SampleInt = 120;
objResult.Formatters.Add(new XmlSerializerOutputFormatter());
base.OnResultExecuting(context);
}
public override void OnResultExecuting(ResultExecutingContext context)
{
var controllerActionDescriptor = (ControllerActionDescriptor)context.ActionDescriptor;
if (controllerActionDescriptor.MethodInfo ==
typeof(ProductsController).GetMethod(nameof(ProductsController.GetPrice)))
{
context.HttpContext.Response.Headers.Append("filters",
"On Action Result Filter - OnResultExecuting");
}
}
public void Wrap(ResultExecutingContext actionResult)
{
var jsonResult = actionResult.Result as JsonResult;
if (jsonResult == null)
{
throw new ArgumentException($"{nameof(actionResult)} should be JsonResult!");
}
if (!(jsonResult.Value is AjaxResponseBase))
{
jsonResult.Value = new AjaxResponse(jsonResult.Value);
}
}
public void OnResultExecuting(ResultExecutingContext context)
{
var controllerActionDescriptor = (ControllerActionDescriptor)context.ActionDescriptor;
if (controllerActionDescriptor.MethodInfo ==
typeof(ResultFilterController).GetMethod(nameof(ResultFilterController.GetHelloWorld)))
{
context.Result = Helpers.GetContentResult(context.Result, "GlobalResultFilter.OnResultExecuting");
}
if (controllerActionDescriptor.MethodInfo ==
typeof(ProductsController).GetMethod(nameof(ProductsController.GetPrice)))
{
context.HttpContext.Response.Headers.Append("filters",
"Global Result Filter - OnResultExecuted");
}
}
public void OnResultExecuting(ResultExecutingContext context)
{
var methodInfo = context.ActionDescriptor.GetMethodInfo();
var wrapResultAttribute =
ReflectionHelper.GetSingleAttributeOfMemberOrDeclaringTypeOrDefault<WrapResultAttribute>(
methodInfo,
WrapResultAttribute.Default
);
if (!wrapResultAttribute.WrapOnSuccess)
{
return;
}
AbpActionResultWrapperFactory
.CreateFor(context.Result)
.Wrap(context.Result);
}
/// <inheritdoc />
public virtual async Task OnResultExecutionAsync(
ResultExecutingContext context,
ResultExecutionDelegate next)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
OnResultExecuting(context);
if (!context.Cancel)
{
OnResultExecuted(await next());
}
}
public void FormatFilter_ContextContainsFormat_InRouteAndQueryData()
{
// If the format is present in both route and query data, the one in route data wins
// Arrange
var mediaType = new StringSegment("application/json");
var mockObjects = new MockObjects("json", FormatSource.RouteData);
var httpContext = new Mock<HttpContext>();
httpContext.Setup(c => c.Response).Returns(new Mock<HttpResponse>().Object);
// Query contains xml
httpContext.Setup(c => c.Request.Query.ContainsKey("format")).Returns(true);
httpContext.Setup(c => c.Request.Query["format"]).Returns("xml");
// Routedata contains json
var data = new RouteData();
data.Values.Add("format", "json");
var ac = new ActionContext(httpContext.Object, data, new ActionDescriptor());
var resultExecutingContext = new ResultExecutingContext(
ac,
new IFilterMetadata[] { },
new ObjectResult("Hello!"),
controller: new object());
var resourceExecutingContext = new ResourceExecutingContext(
ac,
new IFilterMetadata[] { });
var filter = new FormatFilter(mockObjects.OptionsManager);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
filter.OnResultExecuting(resultExecutingContext);
// Assert
var objectResult = Assert.IsType<ObjectResult>(resultExecutingContext.Result);
Assert.Equal(1, objectResult.ContentTypes.Count);
MediaTypeAssert.Equal(mediaType, objectResult.ContentTypes[0]);
}
/// <inheritdoc />
public async Task OnResultExecutionAsync(
ResultExecutingContext context,
ResultExecutionDelegate next)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (next == null)
{
throw new ArgumentNullException(nameof(next));
}
var controller = context.Controller;
if (controller == null)
{
throw new InvalidOperationException(Resources.FormatPropertyOfTypeCannotBeNull(
nameof(context.Controller),
nameof(ResultExecutingContext)));
}
IAsyncResultFilter asyncResultFilter;
IResultFilter resultFilter;
if ((asyncResultFilter = controller as IAsyncResultFilter) != null)
{
await asyncResultFilter.OnResultExecutionAsync(context, next);
}
else if ((resultFilter = controller as IResultFilter) != null)
{
resultFilter.OnResultExecuting(context);
if (!context.Cancel)
{
resultFilter.OnResultExecuted(await next());
}
}
else
{
await next();
}
}
public virtual void OnResultExecuting(ResultExecutingContext context)
{
if (_configuration.SetNoCacheForAjaxResponses && context.HttpContext.Request.IsAjaxRequest())
{
SetNoCache(context);
}
var methodInfo = context.ActionDescriptor.GetMethodInfo();
var wrapResultAttribute =
ReflectionHelper.GetSingleAttributeOfMemberOrDeclaringTypeOrDefault(
methodInfo,
_configuration.DefaultWrapResultAttribute
);
if (!wrapResultAttribute.WrapOnSuccess)
{
return;
}
AbpActionResultWrapperFactory
.CreateFor(context)
.Wrap(context);
}
public override void OnResultExecuting(ResultExecutingContext context)
{
_logger.LogInformation("OnResultExecuting");
base.OnResultExecuting(context);
}
public void Wrap(ResultExecutingContext actionResult)
{
actionResult.Result = new ObjectResult(new AjaxResponse());
}
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 context)
{
_logger.LogWarning("ClassFilter OnResultExecuting");
base.OnResultExecuting(context);
}
public void Wrap(ResultExecutingContext actionResult)
{
}
public void OnResultExecuting(ResultExecutingContext context)
{
context.HttpContext.Response.Headers.Add(
"Internal", new string[] { "Header Added" });
}
public void OnResultExecuting(ResultExecutingContext filterContext)
{
if ((filterContext.Result is ViewResult) || _shouldDeleteCookie)
{
_httpContextAccessor.HttpContext.Response.Cookies.Delete(CookiePrefix, new CookieOptions { Path = _tenantPath });
}
if (!(filterContext.Result is ViewResult))
{
return;
}
var messageEntries = _existingEntries ?? new List<NotifyEntry>();
if (messageEntries.Count == 0)
{
return;
}
var messagesZone = _layoutAccessor.GetLayout().Zones["Messages"];
foreach (var messageEntry in messageEntries)
{
messagesZone = messagesZone.Add(_shapeFactory.Message(messageEntry));
}
}
private static ResultExecutedContext CreateResultExecutedContext(ResultExecutingContext context)
{
return new ResultExecutedContext(context, context.Filters, context.Result, context.Controller);
}
/// <summary>
/// Sets a Content Type on an <see cref="ObjectResult" /> using a format value from the request.
/// </summary>
/// <param name="context">The <see cref="ResultExecutingContext"/>.</param>
public void OnResultExecuting(ResultExecutingContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
var format = GetFormat(context);
if (format == null)
{
// no format specified by user, so the filter is muted
return;
}
var objectResult = context.Result as ObjectResult;
if (objectResult == null)
{
return;
}
// If the action sets a single content type, then it takes precedence over the user
// supplied content type based on format mapping.
if ((objectResult.ContentTypes != null && objectResult.ContentTypes.Count == 1) ||
!string.IsNullOrEmpty(context.HttpContext.Response.ContentType))
{
return;
}
var contentType = _options.FormatterMappings.GetMediaTypeMappingForFormat(format);
objectResult.ContentTypes.Clear();
objectResult.ContentTypes.Add(contentType);
}
private static ResultExecutedContext CreateResultExecutedContext(ResultExecutingContext context)
{
return(new ResultExecutedContext(context, context.Filters, context.Result, context.Controller));
}
public void OnResultExecuting(ResultExecutingContext context)
{
var services = context.HttpContext.RequestServices;
var disabler = services.GetRequiredService<ITranslatorDisabler>();
var cache = services.GetRequiredService<ITranslatedCaching>();
var translator = services.GetRequiredService<ITranslator>();
var culture = services.GetRequiredService<ICultureProvider>().DetermineCulture();
if (context.Result is ViewResult)
{
var result = (ViewResult)context.Result;
if (result.Model == null)
return;
if (result.Model is IEnumerable)
{
var model = (IEnumerable<object>)result.Model;
foreach (var x in model)
{
var type = x.GetType();
var properties = type.GetProperties().Where(y => y.PropertyType == typeof(string) && y.GetCustomAttribute<LocalizedAttribute>() != null);
foreach (var y in properties)
{
try
{
var jsonStr = y.GetValue(x);
var json = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonStr.ToString());
if (json.ContainsKey(culture))
y.SetValue(x, json[culture]);
else
{
var key = json.Keys.FirstOrDefault();
if (key == null)
{
y.SetValue(x, "");
}
else
{
if (disabler.IsDisabled())
y.SetValue(x, json[key]);
(context.Result as ViewResult).ViewData["__IsTranslated"] = true;
var cachedString = cache.Get(json[key], culture);
if (cachedString == null)
{
var translateTask = translator.TranslateAsync(key, culture, json[key]);
translateTask.Wait();
cache.Set(json[key], culture, translateTask.Result);
y.SetValue(x, translateTask.Result);
}
else
{
y.SetValue(x, cachedString);
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
}
}
}
}
else
{
var type = result.Model.GetType();
var properties = type.GetProperties().Where(y => y.PropertyType == typeof(string) && y.GetCustomAttribute<LocalizedAttribute>() != null);
foreach (var y in properties)
{
try
{
var jsonStr = y.GetValue(result.Model);
var json = JsonConvert.DeserializeObject<Dictionary<string, string>>(jsonStr.ToString());
if (json.ContainsKey(culture))
y.SetValue(result.Model, json[culture]);
else
{
var key = json.Keys.FirstOrDefault();
if (key == null)
{
y.SetValue(result.Model, "");
}
else
{
var cachedString = cache.Get(json[key], culture);
if (cachedString == null)
{
var translateTask = translator.TranslateAsync(key, culture, json[key]);
translateTask.Wait();
cache.Set(json[key], culture, translateTask.Result);
y.SetValue(result.Model, translateTask.Result);
}
else
{
y.SetValue(result.Model, cachedString);
}
}
}
}
catch
{
}
}
}
}
}
public static void BeforeOnResultExecution(
this DiagnosticSource diagnosticSource,
ResultExecutingContext resultExecutingContext,
IAsyncResultFilter filter)
{
Debug.Assert(diagnosticSource != null);
Debug.Assert(resultExecutingContext != null);
Debug.Assert(filter != null);
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeOnResultExecution"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.BeforeOnResultExecution",
new
{
actionDescriptor = resultExecutingContext.ActionDescriptor,
resultExecutingContext = resultExecutingContext,
filter = filter
});
}
}
/// <inheritdoc />
public virtual void OnResultExecuting(ResultExecutingContext context)
{
}
public override void OnResultExecuting(ResultExecutingContext filterContext)
{
}
/// <inheritdoc />
public virtual void OnResultExecuting(ResultExecutingContext context)
{
}
public static ControllerActionDescriptor ControllerActionDescriptor(this ResultExecutingContext context) => context.ActionDescriptor.ControllerActionDescriptor();
public void FormatFilter_ExplicitContentType_SetOnResponse_TakesPrecedence()
{
// Arrange
var mediaType = MediaTypeHeaderValue.Parse("application/foo");
var mockObjects = new MockObjects("json", FormatSource.QueryData);
var response = new Mock<HttpResponse>();
response.Setup(r => r.ContentType).Returns("application/foo");
var httpContext = new Mock<HttpContext>();
httpContext.Setup(c => c.Response).Returns(response.Object);
httpContext.Setup(c => c.Request.Query["format"]).Returns("json");
var actionContext = new ActionContext(httpContext.Object, new RouteData(), new ActionDescriptor());
var resultExecutingContext = new ResultExecutingContext(
actionContext,
new IFilterMetadata[] { },
new ObjectResult("Hello!"),
controller: new object());
var resourceExecutingContext = new ResourceExecutingContext(
actionContext,
new IFilterMetadata[] { });
var filter = new FormatFilter(mockObjects.OptionsManager);
// Act
filter.OnResourceExecuting(resourceExecutingContext);
filter.OnResultExecuting(resultExecutingContext);
// Assert
var result = Assert.IsType<ObjectResult>(resultExecutingContext.Result);
Assert.Equal(0, result.ContentTypes.Count);
}
public override void OnResultExecuting(ResultExecutingContext context)
{
context.HttpContext.Response.Headers.Add(
_name, new string[] { _value });
base.OnResultExecuting(context);
}
public override void OnResultExecuting(ResultExecutingContext context)
{
throw new InvalidProgramException("Result Filter threw.");
}
