public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { if (context.HttpContext.Request.Method == "GET") { await HandleQueryResponse(context); } else { await HandleCommandResponse(context); } await next(); }
public override Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { var objectResult = context?.Result as ObjectResult; if (objectResult != null) { var queryContext = context.HttpContext.Items[Constants.QueryContextPropertyName] as QueryContext; var resourceResult = ResultPreprocessor.PreprocessResult(objectResult.Value, this.Resource, queryContext); objectResult.Value = resourceResult; objectResult.DeclaredType = typeof(ResourceResult); } return base.OnResultExecutionAsync(context, next); }
public async Task ProducesAttribute_SetsContentType() { // Arrange var mediaType1 = MediaTypeHeaderValue.Parse("application/json"); var mediaType2 = MediaTypeHeaderValue.Parse("text/json;charset=utf-8"); var producesContentAttribute = new ProducesAttribute("application/json", "text/json;charset=utf-8"); var resultExecutingContext = CreateResultExecutingContext(new IFilterMetadata[] { producesContentAttribute }); var next = new ResultExecutionDelegate( () => Task.FromResult(CreateResultExecutedContext(resultExecutingContext))); // Act await producesContentAttribute.OnResultExecutionAsync(resultExecutingContext, next); // Assert var objectResult = resultExecutingContext.Result as ObjectResult; Assert.Equal(2, objectResult.ContentTypes.Count); ValidateMediaType(mediaType1, objectResult.ContentTypes[0]); ValidateMediaType(mediaType2, objectResult.ContentTypes[1]); }
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()); } }
/// <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 async Task ProducesContentAttribute_FormatFilterAttribute_Active() { // Arrange var producesContentAttribute = new ProducesAttribute("application/xml"); var formatFilter = new Mock<IFormatFilter>(); formatFilter.Setup(f => f.IsActive) .Returns(true); var filters = new IFilterMetadata[] { producesContentAttribute, formatFilter.Object }; var resultExecutingContext = CreateResultExecutingContext(filters); var next = new ResultExecutionDelegate( () => Task.FromResult(CreateResultExecutedContext(resultExecutingContext))); // Act await producesContentAttribute.OnResultExecutionAsync(resultExecutingContext, next); // Assert var objectResult = Assert.IsType<ObjectResult>(resultExecutingContext.Result); Assert.Equal(0, objectResult.ContentTypes.Count); }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { // do something before the action executes foreach (var provider in _providers) { try { await provider.OnActionExecutingAsync(context); } catch (Exception e) { if (_logger.IsEnabled(LogLevel.Error)) { _logger.LogError(e, e.Message); } } } await next(); // do something after the action executes; resultContext.Result will be set foreach (var provider in _providers) { try { await provider.OnActionExecutedAsync(context); } catch (Exception e) { if (_logger.IsEnabled(LogLevel.Error)) { _logger.LogError(e, e.Message); } } } }
public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { ObjectResult resultFromAction = context.Result as ObjectResult; if (resultFromAction?.Value == null || resultFromAction.StatusCode < 200 || resultFromAction.StatusCode >= 300) { await next(); return; } var(book, bookCovers) = ((Entities.Book, IEnumerable <ExternalModels.BookCover>))resultFromAction.Value; var mapper = context.HttpContext.RequestServices.GetRequiredService <IMapper>(); var mappedBook = mapper.Map <BookWithCovers>(book); resultFromAction.Value = mapper.Map(bookCovers, mappedBook); await next(); }
public override async Task OnResultExecutionAsync( ResultExecutingContext context, ResultExecutionDelegate next) { var resultFromAction = context.Result as ObjectResult; //If no result value or responses other than 200 statuses if (resultFromAction?.Value == null || resultFromAction.StatusCode < 200 || resultFromAction.StatusCode >= 300) { await next(); return; } //Get Automapper services var mapper = context.HttpContext.RequestServices.GetRequiredService <IMapper>(); //Map the result value using Automapper resultFromAction.Value = mapper.Map <IEnumerable <Models.Book> >(resultFromAction.Value); await next(); }
public async Task ProducesContentAttribute_FormatFilterAttribute_Active() { // Arrange var producesContentAttribute = new ProducesAttribute("application/xml"); var formatFilter = new Mock <IFormatFilter>(); formatFilter.Setup(f => f.IsActive) .Returns(true); var filters = new IFilter[] { producesContentAttribute, formatFilter.Object }; var resultExecutingContext = CreateResultExecutingContext(filters); var next = new ResultExecutionDelegate( () => Task.FromResult(CreateResultExecutedContext(resultExecutingContext))); // Act await producesContentAttribute.OnResultExecutionAsync(resultExecutingContext, next); // Assert var objectResult = Assert.IsType <ObjectResult>(resultExecutingContext.Result); Assert.Equal(0, objectResult.ContentTypes.Count); }
// This is used as a 'common' test method for ActionFilterAttribute and ResultFilterAttribute public static async Task ResultFilter_SettingCancel_ShortCircuits(Mock mock) { // Arrange mock.As <IAsyncResultFilter>() .Setup(f => f.OnResultExecutionAsync( It.IsAny <ResultExecutingContext>(), It.IsAny <ResultExecutionDelegate>())) .CallBase(); mock.As <IResultFilter>() .Setup(f => f.OnResultExecuting(It.IsAny <ResultExecutingContext>())) .Callback <ResultExecutingContext>(c => { mock.ToString(); c.Cancel = true; }); mock.As <IResultFilter>() .Setup(f => f.OnResultExecuted(It.IsAny <ResultExecutedContext>())) .Verifiable(); var context = CreateResultExecutingContext(mock.As <IFilterMetadata>().Object); var next = new ResultExecutionDelegate(() => { throw null; }); // This won't run // Act await mock.As <IAsyncResultFilter>().Object.OnResultExecutionAsync(context, next); // Assert Assert.True(context.Cancel); mock.As <IResultFilter>() .Verify(f => f.OnResultExecuting(It.IsAny <ResultExecutingContext>()), Times.Once()); mock.As <IResultFilter>() .Verify(f => f.OnResultExecuted(It.IsAny <ResultExecutedContext>()), Times.Never()); }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { // determine the result if (context.Result != null) { // now we need to determine if its a 2xx and change it to a 204 // or if it's a 4xx and change it to a 404 not found if (context.Result is StatusCodeResult statusResult) { // todo: log if (statusResult.StatusCode >= (int)HttpStatusCode.OK && statusResult.StatusCode <= 299) { context.Result = new NoContentResult(); } if (statusResult.StatusCode >= (int)HttpStatusCode.BadRequest && statusResult.StatusCode <= 499) { context.Result = new NotFoundResult(); } } else { // todo: log the result context.Result = null; } } if (context.Result == null) { context.Result = new NoContentResult(); } await next(); }
// This is used as a 'common' test method for ActionFilterAttribute and ResultFilterAttribute public static async Task ResultFilter_SettingResult_DoesNotShortCircuit(Mock mock) { // Arrange mock.As <IAsyncResultFilter>() .Setup(f => f.OnResultExecutionAsync( It.IsAny <ResultExecutingContext>(), It.IsAny <ResultExecutionDelegate>())) .CallBase(); mock.As <IResultFilter>() .Setup(f => f.OnResultExecuting(It.IsAny <ResultExecutingContext>())) .Callback <ResultExecutingContext>(c => { mock.ToString(); c.Result = new NoOpResult(); }); mock.As <IResultFilter>() .Setup(f => f.OnResultExecuted(It.IsAny <ResultExecutedContext>())) .Verifiable(); var context = CreateResultExecutingContext(mock.As <IFilterMetadata>().Object); var next = new ResultExecutionDelegate(() => Task.FromResult(CreateResultExecutedContext(context))); // Act await mock.As <IAsyncResultFilter>().Object.OnResultExecutionAsync(context, next); // Assert Assert.False(context.Cancel); mock.As <IResultFilter>() .Verify(f => f.OnResultExecuting(It.IsAny <ResultExecutingContext>()), Times.Once()); mock.As <IResultFilter>() .Verify(f => f.OnResultExecuted(It.IsAny <ResultExecutedContext>()), Times.Once()); }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { _logger.LogDebug($"{GetType().Name} in "); ControllerActionDescriptor descriptor = context.ActionDescriptor as ControllerActionDescriptor; LogEventInfo logEventInfo = new LogEventInfo(LogLevel.Info, _currentLogger.Name, $"Custom LogEventInfo, loggerName: {_currentLogger.Name}"); logEventInfo.Properties["RequestId"] = context.HttpContext.TraceIdentifier; logEventInfo.Properties["IsSuccess"] = context.HttpContext.Response.StatusCode == (int)HttpStatusCode.OK; logEventInfo.Properties["Controller"] = descriptor.ControllerName; logEventInfo.Properties["Action"] = descriptor.ActionName; logEventInfo.Properties["Request"] = null; logEventInfo.Properties["Response"] = JsonConvert.SerializeObject(context.Result); logEventInfo.Exception = null; _currentLogger.Log(logEventInfo); _logger.LogDebug($"{GetType().Name} next "); await next(); _logger.LogDebug($"{GetType().Name} out "); }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { await next(); //處理成功回傳值 var controller = (BaseController)context.Controller; var result = new { // 取得由 API 返回的狀態碼 Status = controller.Status, // 取得由 API 返回的 Result Code Result = controller.Result, // 取得由 API 返回的資料 data = controller.Data, // 取得由 API 返回的處理訊息 Message = controller.Message }; var json = JsonConvert.SerializeObject(result, Formatting.None); var bytes = Encoding.UTF8.GetBytes(json); int length = bytes.Length; var response = context.HttpContext.Response; //this must be set before start writing into the stream response.ContentLength = length; response.ContentType = "application/json"; await response.Body.WriteAsync(bytes, 0, length); }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { if (context.Result is EmptyResult) { context.Result = new ObjectResult(ResultInfo.Create()); } else if (context.Result is ObjectResult objectResult) { if (objectResult.Value is ResultInfo resultInfo) { context.Result = new ObjectResult(resultInfo); } else { objectResult.StatusCode ??= 200; context.Result = new ObjectResult(ResultInfo.Create( (StatusCode)objectResult.StatusCode, objectResult.StatusCode == 200 ? "Success" : context.Result.GetType().Name.Replace("ObjectResult", ""), objectResult.Value) ); } } _ = await next(); }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { if (context.HttpContext.User.Identity.IsAuthenticated) { var controllerActionDescriptor = context.ActionDescriptor as ControllerActionDescriptor; if (!controllerActionDescriptor.ControllerTypeInfo .IsDefined(typeof(Attributes.SuppressNotifications)) && !controllerActionDescriptor.MethodInfo .IsDefined(typeof(Attributes.SuppressNotifications))) { var notifications = await _userService.GetNotificationsForUser(); if (notifications.Any()) { context.HttpContext.Items[ItemKey.NotificationsList] = notifications; } await next(); if (context.HttpContext.Items[ItemKey.NotificationsDisplayed] as bool? == true) { await _userService.ClearNotificationsForUser(); } } else { await next(); } } else { await next(); } }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { // Should only run on the front-end for a full view if ((context.Result is ViewResult || context.Result is PageResult) && !AdminAttribute.IsApplied(context.HttpContext)) { if (_scriptsCache == null) { var settings = (await _siteService.GetSiteSettingsAsync()).As <MatomoSettings>(); if (!string.IsNullOrWhiteSpace(settings?.SiteID) && !string.IsNullOrWhiteSpace(settings?.ServerUri)) { _scriptsCache = new HtmlString($"<script>var _paq = window._paq || [];_paq.push(['trackPageView']);_paq.push(['enableLinkTracking']);_paq.push(['setTrackerUrl', 'https://{settings.ServerUri}/matomo.php']);_paq.push(['setSiteId', '{settings.SiteID}']);</script> <script src=\"https://{settings.ServerUri}/matomo.js\" async defer></script> "); } } if (_scriptsCache != null) { _resourceManager.RegisterHeadScript(_scriptsCache); } } await next.Invoke(); }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { // Should only run on the front-end for a full view if ((context.Result is ViewResult || context.Result is PageResult) && !AdminAttribute.IsApplied(context.HttpContext)) { if (_scriptsCache == null) { var settings = (await _siteService.GetSiteSettingsAsync()).As <GoogleAdSenseSettings>(); if (!string.IsNullOrWhiteSpace(settings?.PublisherID)) { _scriptsCache = new HtmlString($"\n<script async src=\"https://pagead2.googlesyndication.com/pagead/js/adsbygoogle.js\"></script>"); } } if (_scriptsCache != null) { _resourceManager.RegisterHeadScript(_scriptsCache); } } await next.Invoke(); }
public override Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { if (context.ModelState.IsValid) { return(base.OnResultExecutionAsync(context, next)); } if (context.ModelState.Keys.Any()) { Dictionary <string, string[]> errors = context .ModelState .ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Errors.Select(e => e.ErrorMessage).ToArray()); var resultContent = ResultContent <string> .Failure(HttpStatusCode.BadRequest, "Validation Errors", errors); context.Result = new BadRequestObjectResult(resultContent); } else { context.Result = new BadRequestObjectResult(context.ModelState); } return(base.OnResultExecutionAsync(context, next)); }
/// <inheritdoc /> public 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))); } if (controller is IAsyncResultFilter asyncResultFilter) { return(asyncResultFilter.OnResultExecutionAsync(context, next)); } else if (controller is IResultFilter resultFilter) { return(ExecuteResultFilter(context, next, resultFilter)); } else { return(next()); } }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { var apiResponse = ApiResponseContract.From(_notificationContext.Notifications); if ((context.Result is OkObjectResult || context.Result is NoContentResult || context.Result is CreatedResult) && !apiResponse.Success) { var json = JsonConvert.SerializeObject(apiResponse.ToJson(), new JsonSerializerSettings { ContractResolver = new CamelCasePropertyNamesContractResolver() }); context.HttpContext.Response.StatusCode = StatusCodes.Status400BadRequest; context.HttpContext.Response.ContentType = "application/json"; await context.HttpContext.Response.WriteAsync(json); } if (!context.HttpContext.Response.HasStarted) { await next(); } }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { // do something before the action executes await next(); //after the action executes var timingSession = ProfilingSession.Current.Profiler.GetTimingSession(); if (timingSession != null) { string sessionId = timingSession.Id.ToString(); List <CoreProfilerModulecs> coreProfilerModulecs = new List <CoreProfilerModulecs>(); foreach (var timing in timingSession.Timings) { long duration = 0; if (timing.Name.ToLowerInvariant() == "root" && timing.DurationMilliseconds <= 0) { duration = timingSession.DurationMilliseconds; } coreProfilerModulecs.Add(new CoreProfilerModulecs { SessionId = sessionId, ParentId = timing.ParentId.HasValue ? timing.ParentId.Value.ToString() : "", Machine = timingSession.MachineName, Type = timing.Type, CurrentId = timing.Id.ToString(), Name = timing.Name, Start = timing.StartMilliseconds, Duration = duration > 0 ? duration : timing.DurationMilliseconds, Sort = timing.Sort, Started = timing.Started }); } await _coreProfilerRepository.BulkInsertAsync(coreProfilerModulecs); } }
public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { if (Configuration.AuditDisabled || IsActionIgnored(context.ActionDescriptor)) { await next.Invoke(); return; } var resultExecutionContext = await next.Invoke(); await AfterResultAsync(resultExecutionContext); }
public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { var resultFromAction = context.Result as ObjectResult; if (resultFromAction?.Value == null || resultFromAction.StatusCode < 200 || resultFromAction.StatusCode >= 300) { await next(); return; } //var (book, bookCovers) = // ((Entities.Book book, IEnumerable<ExternalModels.BookCover> bookCovers))resultFromAction.Value; // // to check if we can simplify naming //var temp = ((Entities.Book, IEnumerable<ExternalModels.BookCover>)) resultFromAction.Value; var(book, bookCovers) = ((Entities.Book, IEnumerable <ExternalModels.BookCover>))resultFromAction.Value; // this means we can simplify names in BooksController var mappedBook = Mapper.Map <BookWithCovers>(book); resultFromAction.Value = Mapper.Map(bookCovers, mappedBook); await next(); }
/// <summary> /// 执行生成 /// </summary> public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { await WriteViewToFileAsync(context); await base.OnResultExecutionAsync(context, next); }
public async Task OnResultExecutionAsync(ResultExecutingContext filterContext, ResultExecutionDelegate next) { // Should only run on a full view rendering result if (!(filterContext.Result is ViewResult)) { await next(); return; } // Should only run on the Admin if (!AdminAttribute.IsApplied(filterContext.HttpContext)) { await next(); return; } // Should only run for authenticated users if (!filterContext.HttpContext.User.Identity.IsAuthenticated) { await next(); return; } // Don't create the menu if the status code is 3xx var statusCode = filterContext.HttpContext.Response.StatusCode; if (statusCode >= 300 && statusCode < 400) { await next(); return; } // Populate main nav var menuShape = await _shapeFactory.CreateAsync("Navigation", Arguments.From(new { MenuName = "admin", RouteData = filterContext.RouteData, })); dynamic layout = await _layoutAccessor.GetLayoutAsync(); layout.Navigation.Add(menuShape); await next(); }
public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { if (context.HttpContext.Request.Cookies.ContainsKey(CookieNames.SeenOutageMessage) == false) { if (string.IsNullOrEmpty(_systemConfig.PlannedOutageMessage) == false) { var ctrlr = (Controller)context.Controller; ctrlr.ViewData.Add(ViewDataKeys.CanShowOutageMessage, true); ctrlr.ViewData.Add(ViewDataKeys.PlannedOutageMessage, _systemConfig.PlannedOutageMessage); } } await next(); }
public override Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { return(base.OnResultExecutionAsync(context, next)); }
public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { var resultFromAction = context.Result as ObjectResult; if (resultFromAction?.Value == null || resultFromAction.StatusCode < 200 || resultFromAction.StatusCode >= 300) { await next(); return; } resultFromAction.Value = Mapper.Map <IEnumerable <ViewModels.CustomerView> >(resultFromAction.Value); await next(); }
public async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { // Should only run on the front-end for a full view if ((context.Result is ViewResult || context.Result is PageResult) && !AdminAttribute.IsApplied(context.HttpContext)) { // Even if the Admin attribute is not applied we might be using the admin theme, for instance in Login views. // In this case don't render Layers. var selectedTheme = (await _themeManager.GetThemeAsync())?.Id; var adminTheme = await _adminThemeService.GetAdminThemeNameAsync(); if (selectedTheme == adminTheme) { await next.Invoke(); return; } var widgets = await _memoryCache.GetOrCreateAsync("OrchardCore.Layers.LayerFilter:AllWidgets", entry => { entry.AddExpirationToken(_signal.GetToken(LayerMetadataHandler.LayerChangeToken)); return(_layerService.GetLayerWidgetsAsync(x => x.Published)); }); var layers = (await _layerService.GetLayersAsync()).Layers.ToDictionary(x => x.Name); dynamic layout = await _layoutAccessor.GetLayoutAsync(); var updater = _modelUpdaterAccessor.ModelUpdater; var engine = _scriptingManager.GetScriptingEngine("js"); var scope = engine.CreateScope(_scriptingManager.GlobalMethodProviders.SelectMany(x => x.GetMethods()), _serviceProvider, null, null); var layersCache = new Dictionary <string, bool>(); foreach (var widget in widgets) { var layer = layers[widget.Layer]; if (layer == null) { continue; } bool display; if (!layersCache.TryGetValue(layer.Name, out display)) { if (String.IsNullOrEmpty(layer.Rule)) { display = false; } else { display = Convert.ToBoolean(engine.Evaluate(scope, layer.Rule)); } layersCache[layer.Rule] = display; } if (!display) { continue; } var widgetContent = await _contentItemDisplayManager.BuildDisplayAsync(widget.ContentItem, updater); widgetContent.Classes.Add("widget"); widgetContent.Classes.Add("widget-" + widget.ContentItem.ContentType.HtmlClassify()); var wrapper = new WidgetWrapper { Widget = widget.ContentItem, Content = widgetContent }; wrapper.Metadata.Alternates.Add("Widget_Wrapper__" + widget.ContentItem.ContentType); wrapper.Metadata.Alternates.Add("Widget_Wrapper__Zone__" + widget.Zone); var contentZone = layout.Zones[widget.Zone]; contentZone.Add(wrapper); } } await next.Invoke(); }
public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { // return base.OnResultExecutionAsync(context, next); var resultFromAction = context.Result as ObjectResult; if (resultFromAction?.Value == null || resultFromAction.StatusCode < 200 || resultFromAction.StatusCode >= 300) { await next(); return; } resultFromAction.Value = AutoMapper.Mapper.Map <IEnumerable <Models.Book> >(resultFromAction.Value); await next(); }
/// <summary> /// 执行后 /// </summary> /// <param name="context"></param> /// <param name="next"></param> /// <returns></returns> public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { //if (context.HttpContext.Response.StatusCode == 404) //{ // context.HttpContext.Response.Redirect("login/InternalError"); //} await base.OnResultExecutionAsync(context, next); }
public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { //TODO: invalidate cache, this is inefficient var robots = await _robotService.GetRobotsBy(string.Empty, null); _helpersManager.Cache.Set((DateTime.Today, ActorType.Robot), robots.Select(e => new RobotViewModel(e)).ToArray()); await next(); }
public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { var result = context.Result as ObjectResult; if (result.Value == null || result.StatusCode < 200 || result.StatusCode >= 300) { await next(); return; } result.Value = new PersonReplyDto().CopyPropertiesFrom(result.Value); await next(); }
public override async Task OnResultExecutionAsync(ResultExecutingContext context, ResultExecutionDelegate next) { try { if (_resultProvider.HasAnyPolicy(context.Result, out ObjectResult result)) { var finalResult = await _resultProvider.GetContentResultAsync(result).ConfigureAwait(false); if (finalResult != null) { context.Result = finalResult; } } } catch (Exception ex) { _logger.LogWarning(ex, "Something went wrong while processing link generation."); } await base.OnResultExecutionAsync(context, next).ConfigureAwait(false); }
// This is used as a 'common' test method for ActionFilterAttribute and ResultFilterAttribute public static async Task ResultFilter_Calls_OnResultExecuted(Mock mock) { // Arrange mock.As<IAsyncResultFilter>() .Setup(f => f.OnResultExecutionAsync( It.IsAny<ResultExecutingContext>(), It.IsAny<ResultExecutionDelegate>())) .CallBase(); mock.As<IResultFilter>() .Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>())) .Verifiable(); mock.As<IResultFilter>() .Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>())) .Verifiable(); var context = CreateResultExecutingContext(mock.As<IFilter>().Object); var next = new ResultExecutionDelegate(() => Task.FromResult(CreateResultExecutedContext(context))); // Act await mock.As<IAsyncResultFilter>().Object.OnResultExecutionAsync(context, next); // Assert Assert.False(context.Cancel); mock.As<IResultFilter>() .Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once()); mock.As<IResultFilter>() .Verify(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()), Times.Once()); }
// This is used as a 'common' test method for ActionFilterAttribute and ResultFilterAttribute public static async Task ResultFilter_SettingCancel_ShortCircuits(Mock mock) { // Arrange mock.As<IAsyncResultFilter>() .Setup(f => f.OnResultExecutionAsync( It.IsAny<ResultExecutingContext>(), It.IsAny<ResultExecutionDelegate>())) .CallBase(); mock.As<IResultFilter>() .Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>())) .Callback<ResultExecutingContext>(c => { mock.ToString(); c.Cancel = true; }); mock.As<IResultFilter>() .Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>())) .Verifiable(); var context = CreateResultExecutingContext(mock.As<IFilter>().Object); var next = new ResultExecutionDelegate(() => { throw null; }); // This won't run // Act await mock.As<IAsyncResultFilter>().Object.OnResultExecutionAsync(context, next); // Assert Assert.True(context.Cancel); mock.As<IResultFilter>() .Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once()); mock.As<IResultFilter>() .Verify(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()), Times.Never()); }
// This is used as a 'common' test method for ActionFilterAttribute and ResultFilterAttribute public static async Task ResultFilter_SettingResult_DoesNotShortCircuit(Mock mock) { // Arrange mock.As<IAsyncResultFilter>() .Setup(f => f.OnResultExecutionAsync( It.IsAny<ResultExecutingContext>(), It.IsAny<ResultExecutionDelegate>())) .CallBase(); mock.As<IResultFilter>() .Setup(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>())) .Callback<ResultExecutingContext>(c => { mock.ToString(); c.Result = new NoOpResult(); }); mock.As<IResultFilter>() .Setup(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>())) .Verifiable(); var context = CreateResultExecutingContext(mock.As<IFilter>().Object); var next = new ResultExecutionDelegate(() => Task.FromResult(CreateResultExecutedContext(context))); // Act await mock.As<IAsyncResultFilter>().Object.OnResultExecutionAsync(context, next); // Assert Assert.False(context.Cancel); mock.As<IResultFilter>() .Verify(f => f.OnResultExecuting(It.IsAny<ResultExecutingContext>()), Times.Once()); mock.As<IResultFilter>() .Verify(f => f.OnResultExecuted(It.IsAny<ResultExecutedContext>()), Times.Once()); }