public FilterContextBuilder WithResult(IActionResult result)
{
this.result = result;
return this;
}
protected void CompleteAction(IActionResult result)
{
if (ActionCompleted != null)
{
ActionCompleted(this, new ActionResultEventArgs(result));
}
}
/// <summary>
/// Redirects to another page.
/// </summary>
/// <param name="context"></param>
/// <param name="action"></param>
/// <returns></returns>
private ProcessingResult ProcessRedirect(RequestContext context, IActionResult action)
{
var redirect = (Redirect) action;
context.Response.Status = HttpStatusCode.Redirect;
context.Response.Add(new StringHeader("Location", redirect.Location));
return ProcessingResult.SendResponse;
}
public AlertDecoratorResult(IActionResult innerResult, string alertClass, string message, bool appendToExistingMessages = false)
{
InnerResult = innerResult;
AlertClass = alertClass;
Message = message;
AppendToExistingMessages = appendToExistingMessages;
}
/// <summary>
/// Sets Content-Type to "application/javascript" and sends the java script as the body.
/// </summary>
/// <param name="context"></param>
/// <param name="action"></param>
/// <returns></returns>
private ProcessingResult ProcessExecuteJavascript(RequestContext context, IActionResult action)
{
var js = (ExecuteJavascript)action;
context.Response.ContentType.Value = "application/javascript";
byte[] bytes = Encoding.UTF8.GetBytes(js.Value);
context.Response.Body.Write(bytes, 0, bytes.Length);
return ProcessingResult.SendResponse;
}
/// <summary>
/// Creates a javascript alert.
/// </summary>
/// <param name="context"></param>
/// <param name="action"></param>
/// <returns></returns>
private ProcessingResult ProcessJavascriptAlert(RequestContext context, IActionResult action)
{
var alert = (JavascriptAlert) action;
context.Response.ContentType.Value = "application/javascript";
string body = "alert('" + alert.Message.Replace("'", "\\'").Replace("\n", "\\n").Replace("\r", "") + "');";
byte[] bytes = Encoding.UTF8.GetBytes(body);
context.Response.Body.Write(bytes, 0, bytes.Length);
return ProcessingResult.SendResponse;
}
/// <summary>
/// Initialize a new <see cref="ActionResultException"/> with specified <see cref="IActionResult"/> and information.
/// </summary>
/// <param name="message">The message for this exception.</param>
/// <param name="inner">The inner exception for this exception.</param>
/// <param name="result">The <see cref="IActionResult"/> object which will be returned when this exception is handled.</param>
public ActionResultException(string message, Exception inner, IActionResult result) : base(message, inner)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
Result = result;
}
/// <summary>
/// Initialize a new <see cref="ActionResultException"/> with specified <see cref="IActionResult"/>.
/// </summary>
/// <param name="result">The <see cref="IActionResult"/> object which will be returned when this exception is handled.</param>
public ActionResultException(IActionResult result)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
Result = result;
}
public ResultExecutingContext(
ActionContext actionContext,
IList<IFilterMetadata> filters,
IActionResult result,
object controller)
: base(actionContext, filters)
{
Result = result;
Controller = controller;
}
/// <summary>
/// Returns pure string content.
/// </summary>
/// <param name="context"></param>
/// <param name="action"></param>
/// <returns></returns>
private ProcessingResult ProcessStringContent(RequestContext context, IActionResult action)
{
var content = (StringContent) action;
context.Response.ContentLength.Value = context.Response.Encoding.GetByteCount(content.Body);
if (content.ContentType != null)
context.Response.ContentType.Value = content.ContentType;
var writer = new ResponseWriter();
writer.SendHeaders(context.HttpContext, context.Response);
writer.Send(context.HttpContext, content.Body, context.Response.Encoding);
context.HttpContext.Stream.Flush();
return ProcessingResult.Abort;
}
public void Wrap(IActionResult actionResult)
{
var objectResult = actionResult as ObjectResult;
if (objectResult == null)
{
throw new ArgumentException($"{nameof(actionResult)} should be ObjectResult!");
}
if (!(objectResult.Value is AjaxResponse))
{
objectResult.Value = new AjaxResponse(objectResult.Value);
}
}
public void Wrap(IActionResult actionResult)
{
var jsonResult = actionResult as JsonResult;
if (jsonResult == null)
{
throw new ArgumentException($"{nameof(actionResult)} should be JsonResult!");
}
if (!(jsonResult.Value is AjaxResponse))
{
jsonResult.Value = new AjaxResponse(jsonResult.Value);
}
}
public static IAbpActionResultWrapper CreateFor(IActionResult actionResult)
{
if (actionResult is ObjectResult)
{
return new AbpObjectActionResultWrapper();
}
if (actionResult is JsonResult)
{
return new AbpJsonActionResultWrapper();
}
return new NullAbpActionResultWrapper();
}
public ResultExecutedContext(
ActionContext actionContext,
IList<IFilterMetadata> filters,
IActionResult result,
object controller)
: base(actionContext, filters)
{
if (result == null)
{
throw new ArgumentNullException(nameof(result));
}
Result = result;
Controller = controller;
}
public static void AfterActionResult(
this DiagnosticSource diagnosticSource,
ActionContext actionContext,
IActionResult result)
{
Debug.Assert(diagnosticSource != null);
Debug.Assert(actionContext != null);
Debug.Assert(result != null);
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterActionResult"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.AfterActionResult",
new { actionContext = actionContext, result = result });
}
}
private ProcessingResult ProcessStream(RequestContext context, IActionResult action)
{
StreamResult result = (StreamResult) action;
if (context.Response.ContentType.Value == "text/html")
context.Response.ContentType.Value = "application/octet-stream";
context.Response.ContentLength.Value = result.Stream.Length;
ResponseWriter writer = new ResponseWriter();
writer.SendHeaders(context.HttpContext, context.Response);
byte[] buffer = new byte[8196];
int bytesRead = result.Stream.Read(buffer, 0, buffer.Length);
while (bytesRead > 0)
{
context.HttpContext.Stream.Write(buffer, 0, bytesRead);
bytesRead = result.Stream.Read(buffer, 0, buffer.Length);
}
return ProcessingResult.Abort;
}
public static LinkGenerationTestContext FromRedirectResult(IActionResult actionResult)
{
var redirectToRouteResult = actionResult as RedirectToRouteResult;
if (redirectToRouteResult != null)
{
redirectToRouteResult.RouteValues = redirectToRouteResult.RouteValues ?? new RouteValueDictionary();
return new LinkGenerationTestContext
{
UrlHelper = redirectToRouteResult.UrlHelper,
RouteName = redirectToRouteResult.RouteName,
RouteValues = new SortedDictionary<string, object>(redirectToRouteResult.RouteValues)
};
}
var redirectToActionResult = actionResult as RedirectToActionResult;
if (redirectToActionResult != null)
{
redirectToActionResult.RouteValues = redirectToActionResult.RouteValues ?? new RouteValueDictionary();
return new LinkGenerationTestContext
{
UrlHelper = redirectToActionResult.UrlHelper,
Controller = redirectToActionResult.ControllerName,
Action = redirectToActionResult.ActionName,
RouteValues = new SortedDictionary<string, object>(redirectToActionResult.RouteValues)
};
}
var redirectResult = actionResult as RedirectResult;
if (redirectResult != null)
{
return new LinkGenerationTestContext
{
Location = redirectResult.Url,
UrlHelper = redirectResult.UrlHelper
};
}
return null;
}
public static LinkGenerationTestContext FromCreatedResult(IActionResult actionResult)
{
var createdAtRouteResult = actionResult as CreatedAtRouteResult;
if (createdAtRouteResult != null)
{
createdAtRouteResult.RouteValues = createdAtRouteResult.RouteValues ?? new RouteValueDictionary();
return new LinkGenerationTestContext
{
UrlHelper = createdAtRouteResult.UrlHelper,
RouteName = createdAtRouteResult.RouteName,
RouteValues = new SortedDictionary<string, object>(createdAtRouteResult.RouteValues)
};
}
var createdAtActionResult = actionResult as CreatedAtActionResult;
if (createdAtActionResult != null)
{
createdAtActionResult.RouteValues = createdAtActionResult.RouteValues ?? new RouteValueDictionary();
return new LinkGenerationTestContext
{
UrlHelper = createdAtActionResult.UrlHelper,
Controller = createdAtActionResult.ControllerName,
Action = createdAtActionResult.ActionName,
RouteValues = new SortedDictionary<string, object>(createdAtActionResult.RouteValues)
};
}
var createdResult = actionResult as CreatedResult;
if (createdResult != null)
{
return new LinkGenerationTestContext
{
Location = createdResult.Location
};
}
return null;
}
protected RedirectToRouteResult RedirectToPage(IActionResult result)
{
var callInfo = result.GetR4ActionResult();
return(RedirectToRoute(callInfo.RouteValueDictionary));
}
public async Task GetOverview_GivenSomeEvents_EventsSortedByDateOfUpcomingAppointment()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
(Event eventWithoutAppointments, Event eventWithSoonerAppointment, Event eventWithLaterAppointment)yourEvents;
(Event eventWithoutAppointments, Event eventWithSoonerAppointment, Event eventWithLaterAppointment)publicEvents;
int johnId;
// Arrange
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
User richard = ContextUtilities.CreateRichardRoe();
yourEvents = CreateEvents(context, john);
publicEvents = CreateEvents(context, richard);
await context.SaveChangesAsync();
johnId = john.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnId);
IActionResult response = await participateEventController.GetOverview();
// Assert
Assert.IsType <OkObjectResult>(response);
var okObjectResult = (OkObjectResult)response;
var eventOverview = okObjectResult.Value as EventOverview;
Assert.NotNull(eventOverview);
AssertEventOrder(eventOverview.YourEvents, yourEvents);
AssertEventOrder(eventOverview.PublicEvents, publicEvents);
(Event eventWithoutAppointments, Event eventWithSoonerAppointment, Event eventWithLaterAppointment) CreateEvents(IDatabaseContext context, User organizer)
{
Event eventWithoutAppointments = DummyEvent(organizer);
Event eventWithSoonerAppointment = DummyEvent(organizer);
Event eventWithLaterAppointment = DummyEvent(organizer);
context.Events.Add(eventWithLaterAppointment);
context.Events.Add(eventWithSoonerAppointment);
context.Events.Add(eventWithoutAppointments);
context.Appointments.Add(new Appointment {
Event = eventWithSoonerAppointment, StartTime = DateTime.UtcNow + TimeSpan.FromHours(1)
});
context.Appointments.Add(new Appointment {
Event = eventWithLaterAppointment, StartTime = DateTime.UtcNow + TimeSpan.FromHours(2)
});
return(eventWithoutAppointments, eventWithSoonerAppointment, eventWithLaterAppointment);
}
// ReSharper disable ParameterOnlyUsedForPreconditionCheck.Local
void AssertEventOrder(List <EventOverviewInformation> loadedEvents, (Event eventWithoutAppointments, Event eventWithSoonerAppointment, Event eventWithLaterAppointment) providedEvents)
// ReSharper restore ParameterOnlyUsedForPreconditionCheck.Local
{
Assert.Equal(3, loadedEvents.Count);
Assert.Equal(providedEvents.eventWithSoonerAppointment.Id, loadedEvents[0].EventId);
Assert.Equal(providedEvents.eventWithLaterAppointment.Id, loadedEvents[1].EventId);
Assert.Equal(providedEvents.eventWithoutAppointments.Id, loadedEvents[2].EventId);
}
}
public void Wrap(IActionResult actionResult)
{
}
public async Task GetOverview_GivenAppointmentWithParticipation_SummaryCountsCorrect()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
Event yourEvent;
int johnId;
// Arrange
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
User participantWithExplicitNoAnswer = ContextUtilities.CreateRandomUser();
User participantAccepted = ContextUtilities.CreateRandomUser();
User participantDeclined = ContextUtilities.CreateRandomUser();
yourEvent = DummyEvent(john);
context.Events.Add(yourEvent);
context.EventParticipations.Add(new EventParticipation {
Participant = john, Event = yourEvent
});
context.EventParticipations.Add(new EventParticipation {
Participant = participantWithExplicitNoAnswer, Event = yourEvent
});
context.EventParticipations.Add(new EventParticipation {
Participant = participantAccepted, Event = yourEvent
});
context.EventParticipations.Add(new EventParticipation {
Participant = participantDeclined, Event = yourEvent
});
EntityEntry <Appointment> appointmentEntry = context.Appointments.Add(new Appointment {
Event = yourEvent, StartTime = DateTime.UtcNow + TimeSpan.FromDays(1)
});
context.AppointmentParticipations.Add(new AppointmentParticipation {
Participant = participantWithExplicitNoAnswer, Appointment = appointmentEntry.Entity, AppointmentParticipationAnswer = null
});
context.AppointmentParticipations.Add(new AppointmentParticipation {
Participant = participantAccepted, Appointment = appointmentEntry.Entity, AppointmentParticipationAnswer = AppointmentParticipationAnswer.Accepted
});
context.AppointmentParticipations.Add(new AppointmentParticipation {
Participant = participantDeclined, Appointment = appointmentEntry.Entity, AppointmentParticipationAnswer = AppointmentParticipationAnswer.Declined
});
await context.SaveChangesAsync();
johnId = john.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnId);
IActionResult response = await participateEventController.GetOverview();
// Assert
Assert.IsType <OkObjectResult>(response);
var okObjectResult = (OkObjectResult)response;
var eventOverview = okObjectResult.Value as EventOverview;
Assert.NotNull(eventOverview);
Assert.Empty(eventOverview.PublicEvents);
Assert.Single(eventOverview.YourEvents);
EventOverviewInformation loadedYourEvent = eventOverview.YourEvents[0];
Assert.Equal(yourEvent.Id, loadedYourEvent.EventId);
// TODO Assert.Equal(4, loadedYourEvent.ViewEventInformation.TotalParticipants);
Assert.NotNull(loadedYourEvent.LatestAppointmentDetails);
// TODO Assert.Equal(1, loadedYourEvent.LatestAppointmentInformation.AcceptedParticipants);
// TODO Assert.Equal(1, loadedYourEvent.LatestAppointmentInformation.DeclinedParticipants);
// TODO Assert.Equal(2, loadedYourEvent.LatestAppointmentInformation.NotAnsweredParticipants);
}
protected RedirectToRouteResult RedirectToAction(IActionResult result)
{
var callInfo = result.GetR4MvcResult();
return RedirectToRoute(callInfo.RouteValueDictionary);
}
public void WriteInvalidInput(List <InvalidUseCaseInputValidationError> errors)
{
this.ViewModel = new BadRequestObjectResult(errors);
}
public static void BeforeExecutingActionResult(ILogger logger, IActionResult actionResult)
{
BeforeExecutingActionResult(logger, actionResult.GetType());
}
public static IActionResult WithError(this IActionResult result, string message)
{
return(Alert(result, "alert-danger", message));
}
public static IActionResult WithWarning(this IActionResult result, string message)
{
return(Alert(result, "alert-warning", message));
}
public static IActionResult WithInfo(this IActionResult result, string message)
{
return(Alert(result, "alert-info", message));
}
public static IActionResult WithSuccess(this IActionResult result, string message)
{
return(Alert(result, "alert-success", message));
}
public void Create_ActionExecutes_ReturnsViewForCreate()
{
IActionResult result = PeopleController.Create();
Assert.IsType <ViewResult>(result);
}
public async Task Index_ActionExecutes_ReturnsViewForIndexAsync()
{
IActionResult result = await PeopleController.Index();
Assert.IsType <ViewResult>(result);
}
public async Task Post(CohortDetailsOptions option)
{
_viewModel.Selection = option;
_result = await _controller.Details(_viewModel);
}
/// <summary>
/// Action have been invoked
/// </summary>
/// <param name="result">Result returned by action.</param>
protected virtual void AfterAction(IActionResult result)
{
}
private static void RunSelectRequestsHappyPathTests(IActionResult view, ItineraryDetailsViewModel itinerary, IList<RequestListViewModel> returnedRequests)
{
Assert.IsType<ViewResult>(view);
var result = (ViewResult)view;
Assert.IsType<SelectItineraryRequestsViewModel>(result.Model);
var model = (SelectItineraryRequestsViewModel)result.Model;
Assert.Equal(itinerary.CampaignId, model.CampaignId);
Assert.Equal(itinerary.CampaignName, model.CampaignName);
Assert.Equal(itinerary.EventId, model.EventId);
Assert.Equal(itinerary.EventName, model.EventName);
Assert.Equal(itinerary.Name, model.ItineraryName);
Assert.Equal(returnedRequests.Count, model.Requests.Count);
foreach (var request in returnedRequests)
{
var requestModel = model.Requests.FirstOrDefault(x => x.Id == request.Id);
Assert.Equal(request.Name, requestModel.Name);
Assert.Equal(request.DateAdded, requestModel.DateAdded);
Assert.Equal(request.City, requestModel.City);
Assert.Equal(request.Address, requestModel.Address);
Assert.Equal(request.Latitude, requestModel.Latitude);
Assert.Equal(request.Longitude, requestModel.Longitude);
Assert.Equal(request.Postcode, requestModel.Postcode);
}
}
private static IActionResult Alert(IActionResult result, string type, string body)
{
return(new AlertDecoratorResult(result, type, body));
}
protected override void SetActionResult(IActionResult actionResult)
{
_context.Result = actionResult;
}
protected RedirectToRouteResult RedirectToActionPermanent(IActionResult result)
{
var callInfo = result.GetR4MvcResult();
return(RedirectToRoutePermanent(callInfo.RouteValueDictionary));
}
public void ReturnNotFoundForConfirmDelete()
{
IActionResult result = _sut.ConfirmDelete("wrongId");
Assert.IsType <NotFoundResult>(result);
}
private T GetViewModel <T>(IActionResult result) where T : class
{
return((result as ViewResult)?.ViewData.Model as T);
}
public ActionResultWithNoCachingDecorator(IActionResult actionResult)
: base(actionResult)
{
}
protected int GetStatusCode(IActionResult response)
{
return((int)response.GetType().GetProperty("StatusCode").GetValue(response, null));
}
public ActionResultWithCorsDecorator(string corsSettings, IActionResult actionResult)
: base(actionResult)
{
this.corsSettings = corsSettings;
}
public void ReturnNotFoundForEditAfterPost()
{
IActionResult result = _sut.Edit(new ProductCategory());
Assert.IsType <NotFoundResult>(result);
}
public async Task GetOverview_GivenEventWithAppointments_AppointmentDetailsCorrect()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
DateTime expectedDateTime = DateTime.UtcNow + TimeSpan.FromDays(1);
Event yourEvent;
Event publicEvent;
int johnId;
// Arrange
using (IDatabaseContext context = getContext())
{
User john = ContextUtilities.CreateJohnDoe();
User richard = ContextUtilities.CreateRichardRoe();
yourEvent = CreateEventWithAppointments(context, john, expectedDateTime);
publicEvent = CreateEventWithAppointments(context, richard, expectedDateTime);
await context.SaveChangesAsync();
johnId = john.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnId);
IActionResult response = await participateEventController.GetOverview();
// Assert
Assert.IsType <OkObjectResult>(response);
var okObjectResult = (OkObjectResult)response;
var eventOverview = okObjectResult.Value as EventOverview;
Assert.NotNull(eventOverview);
AssertAppointmentSummary(eventOverview.YourEvents, yourEvent);
AssertAppointmentSummary(eventOverview.PublicEvents, publicEvent);
Event CreateEventWithAppointments(IDatabaseContext context, User organizer, DateTime dateOfNewestAppointment)
{
Event @event = DummyEvent(organizer);
context.Events.Add(@event);
context.Appointments.Add(new Appointment {
Event = @event, StartTime = dateOfNewestAppointment + TimeSpan.FromSeconds(1)
});
context.Appointments.Add(new Appointment {
Event = @event, StartTime = dateOfNewestAppointment
});
context.Appointments.Add(new Appointment {
Event = @event, StartTime = dateOfNewestAppointment + TimeSpan.FromSeconds(2)
});
return(@event);
}
// ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
void AssertAppointmentSummary(IReadOnlyList <EventOverviewInformation> loadedEvents, Event expectedEvent)
{
Assert.Single(loadedEvents);
EventOverviewInformation loadedYourEvent = loadedEvents[0];
Assert.Equal(expectedEvent.Id, loadedYourEvent.EventId);
Assert.Equal(expectedDateTime, loadedYourEvent.LatestAppointmentDetails.StartTime);
}
}
public static IActionResult WithInfo(this IActionResult result, string body)
{
return(Alert(result, "info", body));
}
public async Task GetOverview_GivenParticipatingEvents_ShowsYourAndPublicEvents()
{
GetDatabaseContext getContext = ContextUtilities.CreateInMemoryContext(_output);
int richardsPublicEventId;
int richardsPrivateEventId;
int richardsPublicEventParticipatingId;
int richardsPrivateEventParticipatingId;
int johnId;
// Arrange
using (IDatabaseContext context = getContext())
{
EntityEntry <User> john = context.Users.Add(ContextUtilities.CreateJohnDoe());
User richard = ContextUtilities.CreateRichardRoe();
Event richardsPublicEvent = DummyEvent(richard);
Event richardsPrivateEvent = DummyEvent(richard, true);
Event richardsPublicEventParticipating = DummyEvent(richard);
Event richardsPrivateEventParticipating = DummyEvent(richard, true);
context.Events.Add(richardsPublicEvent);
context.Events.Add(richardsPrivateEvent);
context.Events.Add(richardsPublicEventParticipating);
context.Events.Add(richardsPrivateEventParticipating);
context.EventParticipations.Add(new EventParticipation {
Participant = john.Entity, Event = richardsPublicEventParticipating
});
context.EventParticipations.Add(new EventParticipation {
Participant = john.Entity, Event = richardsPrivateEventParticipating
});
await context.SaveChangesAsync();
richardsPublicEventId = richardsPublicEvent.Id;
richardsPrivateEventId = richardsPrivateEvent.Id;
richardsPublicEventParticipatingId = richardsPublicEventParticipating.Id;
richardsPrivateEventParticipatingId = richardsPrivateEventParticipating.Id;
johnId = john.Entity.Id;
}
// Act
(ParticipateEventController participateEventController, _) = CreateController(getContext, johnId);
IActionResult response = await participateEventController.GetOverview();
// Assert
Assert.IsType <OkObjectResult>(response);
var okObjectResult = (OkObjectResult)response;
var eventOverview = okObjectResult.Value as EventOverview;
Assert.NotNull(eventOverview);
Assert.Single(eventOverview.PublicEvents);
Assert.Equal(2, eventOverview.YourEvents.Count);
Assert.Contains(richardsPublicEventId, eventOverview.PublicEvents.Select(e => e.EventId));
Assert.DoesNotContain(richardsPrivateEventId, eventOverview.PublicEvents.Select(e => e.EventId));
Assert.Contains(richardsPublicEventParticipatingId, eventOverview.YourEvents.Select(e => e.EventId));
Assert.Contains(richardsPrivateEventParticipatingId, eventOverview.YourEvents.Select(e => e.EventId));
}
public static IActionResult WithWarning(this IActionResult result, string body)
{
return(Alert(result, "warning", body));
}
internal void InvokeAfterAction(IActionResult actionResult)
{
AfterAction(actionResult);
}
public static IEnumerable <TViewModel> AsCollectionView <TApiElement, TViewModel>(this IActionResult result)
where TApiElement : IApiResource
where TViewModel : class, new()
{
ObjectResult objResult = (ObjectResult)result;
object value = objResult.Value;
if (objResult is CreatedAtActionResult ||
objResult is AcceptedAtActionResult)
{
value = (value as ObjectResult).Value;
}
if (!(value is CollectionView <TApiElement>))
{
throw new InvalidCastException("This IActionResult is NOT a CollectionView generic wrapper for the " + typeof(TApiElement).Name + " element type.");
}
var view = value as CollectionView <TApiElement>;
var viewModels = view.ViewModels as IEnumerable <TViewModel>;
return(viewModels);
}
public static void BeforeActionResult(
this DiagnosticSource diagnosticSource,
ActionContext actionContext,
IActionResult result)
{
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeActionResult"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.BeforeActionResult",
new { actionContext = actionContext, result = result });
}
}
public static IActionResult PushAlert(this IActionResult view, string message, AlertType type = AlertType.Info)
{
Alertify.Push(message, type);
return(view);
}
public static void AfterExecutingActionResult(ILogger logger, IActionResult actionResult)
{
AfterExecutingActionResult(logger, actionResult.GetType());
}
public StateUpdateException(string message, Exception innerException, IActionResult statusResult) : this(message, innerException)
{
this.StatusResult = statusResult;
}
/// <summary>
/// Initializes a new instance of the <see cref="OperationFailedViewModel" />
/// </summary>
/// <param name="operationName">The name of failed operation</param>
/// <param name="actionResult">The result of an operation</param>
public OperationFailedViewModel(string operationName, IActionResult actionResult)
{
Errors = actionResult.Errors;
_operationName = operationName;
RepeatCommand = new DelegateCommand(OnCloseView);
}
public ActionResultEventArgs(IActionResult actionResult)
{
ActionResult = actionResult;
}
public HttpResponse(IActionResult action)
: this(action.Request.ProtocolVersion, action.StatusCode, action.GetContent(), action.ContentType)
{
}
public void OnAfterActionResult(
IActionContext actionContext,
IActionResult result)
{
var timing = _broker.EndLogicalOperation<BeforeActionResultMessage>();
if (timing != null)
{
var actionDescriptor = ConvertActionDescriptor(actionContext.ActionDescriptor);
var message = new AfterActionResultMessage()
{
ActionId = actionDescriptor.Id,
ActionName = actionDescriptor.Name,
ActionControllerName = actionDescriptor.ControllerName,
ActionResultEndTime = timing.End,
ActionResultDuration = timing.Elapsed,
ActionResultOffset = timing.Offset
};
_broker.SendMessage(message);
}
else
{
_logger.LogCritical("OnAfterActionResult: Couldn't publish `AfterActionResultMessage` as `BeforeActionResultMessage` wasn't found in stack");
}
}
public static IActionResult WithSuccess(this IActionResult result, string body)
{
return(Alert(result, "success", body));
}
public void ReturnNotFoundForDelete()
{
IActionResult result = _sut.Delete("abc123");
Assert.IsType <NotFoundResult>(result);
}
public static void AfterActionMethod(
this DiagnosticSource diagnosticSource,
ActionContext actionContext,
IDictionary<string, object> actionArguments,
object controller,
IActionResult result)
{
Debug.Assert(diagnosticSource != null);
Debug.Assert(actionContext != null);
Debug.Assert(actionArguments != null);
Debug.Assert(controller != null);
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterActionMethod"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.AfterActionMethod",
new
{
actionContext = actionContext,
arguments = actionArguments,
controller = controller,
result = result
});
}
}
