public void AuthRoute(RouteContext ctx)
{
if (ctx.Method.NoAuth)
{
return;
}
var authToken = ctx.HttpRequest.GetHeader("monospad-auth-token");
Guid tokenGuid;
Guid.TryParse(authToken, out tokenGuid);
if (tokenGuid == Guid.Empty)
{
throw Errors.Auth_LoginRequired;
}
var login = _repo.Select<Login>()
.Join(l => l.User)
.FirstOrDefault(l => l.Token == tokenGuid);
if (login == null)
{
throw Errors.Auth_LoginRequired;
}
if (login.ExpireDate < DateTime.UtcNow)
{
throw Errors.Auth_LoginTokenExpired;
}
MonospadContext.Current.Login = login;
}
public void AfterCall(RouteContext ctx)
{
foreach (var interceptor in _interceptors.Reverse())
{
interceptor.AfterCall(ctx);
}
}
public IActionInterceptor Build(RouteContext context)
{
return new MonospadActionInterceptor(
new ValidationInterceptor(),
new UnitOfWorkInterceptor(),
new SecurityInterceptor(_authProvider));
}
public object BeforeCall(RouteContext ctx)
{
if (ctx.Parameters.Length == 1)
{
ValidationManager.Validate(ctx.Parameters[0]);
}
return null;
}
public object BeforeCall(RouteContext ctx)
{
_uow = DependencyContainer.Current.Resolve<IUnitOfWork>();
if (ctx.Method.HttpMethod != HttpMethod.Get)
{
_uow.BeginTransaction();
}
return null;
}
public object BeforeCall(RouteContext ctx)
{
foreach (var interceptor in _interceptors)
{
var res = interceptor.BeforeCall(ctx);
if (res != null)
{
return res;
}
}
return null;
}
public object OnException(RouteContext ctx)
{
foreach (var interceptor in _interceptors.Reverse())
{
var res = interceptor.OnException(ctx);
if (res != null)
{
return res;
}
}
return null;
}
public object OnException(RouteContext ctx)
{
var ex = ctx.Exception as Error ?? Errors.Unknown;
return Response.Error(ex);
}
public string SelectAction(RouteContext routeContext, SelectControllerResult controllerResult, IEnumerable <ControllerActionDescriptor> actionDescriptors)
{
return(SelectActionImpl(routeContext, controllerResult, actionDescriptors));
}
public Task RouteAsync(RouteContext context)
{
throw new NotImplementedException();
}
/// <summary>
/// Determines whether the action selection is valid for the specified route context.
/// </summary>
public override bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action)
{
return(routeContext.HttpContext.Request.IsAjaxRequest());
}
/// <inheritdoc />
public async Task RouteAsync(RouteContext context)
{
foreach (var tree in _trees)
{
var tokenizer = new PathTokenizer(context.HttpContext.Request.Path);
var root = tree.Root;
var treeEnumerator = new TreeEnumerator(root, tokenizer);
// Create a snapshot before processing the route. We'll restore this snapshot before running each
// to restore the state. This is likely an "empty" snapshot, which doesn't allocate.
var snapshot = context.RouteData.PushState(router: null, values: null, dataTokens: null);
while (treeEnumerator.MoveNext())
{
var node = treeEnumerator.Current;
foreach (var item in node.Matches)
{
var entry = item.Entry;
var matcher = item.TemplateMatcher;
try
{
if (!matcher.TryMatch(context.HttpContext.Request.Path, context.RouteData.Values))
{
continue;
}
if (!RouteConstraintMatcher.Match(
entry.Constraints,
context.RouteData.Values,
context.HttpContext,
this,
RouteDirection.IncomingRequest,
_constraintLogger))
{
continue;
}
_logger.RequestMatchedRoute(entry.RouteName, entry.RouteTemplate.TemplateText);
context.RouteData.Routers.Add(entry.Handler);
await entry.Handler.RouteAsync(context);
if (context.Handler != null)
{
return;
}
}
finally
{
if (context.Handler == null)
{
// Restore the original values to prevent polluting the route data.
snapshot.Restore();
}
}
}
}
}
}
public ModuleRouteContext(HttpContext httpContext, RouteContext parentRouteContext) : base(httpContext)
{
_parentRouteContext = parentRouteContext;
RouteData = _parentRouteContext.RouteData;
}
private static async Task <IHtmlContent> RenderActionAsync(this IHtmlHelper helper, string action, string controller, string area, object parameters = null)
{
// fetching required services for invocation
var serviceProvider = helper.ViewContext.HttpContext.RequestServices;
var actionContextAccessor = helper.ViewContext.HttpContext.RequestServices.GetRequiredService <IActionContextAccessor>();
var httpContextAccessor = helper.ViewContext.HttpContext.RequestServices.GetRequiredService <IHttpContextAccessor>();
var actionSelector = serviceProvider.GetRequiredService <IActionSelector>();
// creating new action invocation context
var routeData = new RouteData();
foreach (var router in helper.ViewContext.RouteData.Routers)
{
routeData.PushState(router, null, null);
}
routeData.PushState(null, new RouteValueDictionary(new { controller = controller, action = action, area = area }), null);
routeData.PushState(null, new RouteValueDictionary(parameters ?? new { }), null);
//get the actiondescriptor
RouteContext routeContext = new RouteContext(helper.ViewContext.HttpContext)
{
RouteData = routeData
};
var candidates = actionSelector.SelectCandidates(routeContext);
var actionDescriptor = actionSelector.SelectBestCandidate(routeContext, candidates);
var originalActionContext = actionContextAccessor.ActionContext;
var originalhttpContext = httpContextAccessor.HttpContext;
try
{
var newHttpContext = serviceProvider.GetRequiredService <IHttpContextFactory>().Create(helper.ViewContext.HttpContext.Features);
if (newHttpContext.Items.ContainsKey(typeof(IUrlHelper)))
{
newHttpContext.Items.Remove(typeof(IUrlHelper));
}
newHttpContext.Response.Body = new MemoryStream();
var actionContext = new ActionContext(newHttpContext, routeData, actionDescriptor);
actionContextAccessor.ActionContext = actionContext;
var invoker = serviceProvider.GetRequiredService <IActionInvokerFactory>().CreateInvoker(actionContext);
await invoker.InvokeAsync();
newHttpContext.Response.Body.Position = 0;
using (var reader = new StreamReader(newHttpContext.Response.Body))
{
return(new HtmlString(reader.ReadToEnd()));
}
}
catch (Exception ex)
{
return(new HtmlString(ex.Message));
}
finally
{
actionContextAccessor.ActionContext = originalActionContext;
httpContextAccessor.HttpContext = originalhttpContext;
if (helper.ViewContext.HttpContext.Items.ContainsKey(typeof(IUrlHelper)))
{
helper.ViewContext.HttpContext.Items.Remove(typeof(IUrlHelper));
}
}
}
public Task RouteAsync(RouteContext context)
{
context.Handler = (c) => Task.FromResult(0);
return(Task.FromResult(false));
}
public abstract Task RouteAsync(RouteContext context);
/// <summary> /// Determines whether the action selection is valid for the specified route context. /// </summary> /// <param name="routeContext">The route context.</param> /// <param name="action">Information about the action.</param> /// <returns> /// <see langword="true"/> if the action selection is valid for the specified context; /// otherwise, <see langword="false"/>. /// </returns> public abstract bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action);
protected Mapping()
{
Context = new RouteContext();
}
public HttpValidationStatus Validate(ResponseContext response, RouteContext context)
{
// TODO: Implement response validator
return(HttpValidationStatus.Success());
}
public virtual void RestoreRouteData(RouteContext context, ReusablePipeline pipeline)
{
context.RouteData.Values[_options.Value.PipelineNameRouteDataKey] = pipeline.Name.ToLower();
}
public async Task RouteAsync([NotNull] RouteContext context)
{
var services = context.HttpContext.RequestServices;
// Verify if AddMvc was done before calling UseMvc
// We use the MvcMarkerService to make sure if all the services were added.
MvcServicesHelper.ThrowIfMvcNotRegistered(services);
EnsureServices(context.HttpContext);
var actionDescriptor = await _actionSelector.SelectAsync(context);
if (actionDescriptor == null)
{
_logger.LogVerbose("No actions matched the current request.");
return;
}
// Replacing the route data allows any code running here to dirty the route values or data-tokens
// without affecting something upstream.
var oldRouteData = context.RouteData;
var newRouteData = new RouteData(oldRouteData);
if (actionDescriptor.RouteValueDefaults != null)
{
foreach (var kvp in actionDescriptor.RouteValueDefaults)
{
if (!newRouteData.Values.ContainsKey(kvp.Key))
{
newRouteData.Values.Add(kvp.Key, kvp.Value);
}
}
}
try
{
context.RouteData = newRouteData;
if (_notifier.ShouldNotify("Microsoft.AspNet.Mvc.BeforeAction"))
{
_notifier.Notify(
"Microsoft.AspNet.Mvc.BeforeAction",
new { actionDescriptor, httpContext = context.HttpContext, routeData = context.RouteData });
}
using (_logger.BeginScope("ActionId: {ActionId}", actionDescriptor.Id))
{
_logger.LogVerbose("Executing action {ActionDisplayName}", actionDescriptor.DisplayName);
await InvokeActionAsync(context, actionDescriptor);
context.IsHandled = true;
}
}
finally
{
if (_notifier.ShouldNotify("Microsoft.AspNet.Mvc.AfterAction"))
{
_notifier.Notify(
"Microsoft.AspNet.Mvc.AfterAction",
new { actionDescriptor, httpContext = context.HttpContext });
}
if (!context.IsHandled)
{
context.RouteData = oldRouteData;
}
}
}
public void AfterCall(RouteContext ctx)
{
}
public object OnException(RouteContext ctx)
{
_uow?.Rollback();
return null;
}
public Task RouteAsync(RouteContext context)
{
context.Handler = new ApiActionRouteHandler(_edgeDeserializer, _edgeSerializerProvider,
_apiActionExecutioner, context.RouteData).Handle;
return(CompletedTask);
}
/// <summary>
/// Is valid?
/// </summary>
/// <param name="routeContext">Route context</param>
/// <param name="action">Action descriptor</param>
/// <returns>Result</returns>
public override bool IsValidForRequest(RouteContext routeContext, ActionDescriptor action)
{
if (routeContext.HttpContext.Request.Method != WebRequestMethods.Http.Post)
{
return(false);
}
foreach (var buttonName in _submitButtonNames)
{
try
{
switch (this._requirement)
{
case FormValueRequirement.Equal:
{
if (_validateNameOnly)
{
//"name" only
if (routeContext.HttpContext.Request.Form.Keys.Any(x => x.Equals(buttonName, StringComparison.InvariantCultureIgnoreCase)))
{
return(true);
}
}
else
{
//validate "value"
//do not iterate because "Invalid request" exception can be thrown
string value = routeContext.HttpContext.Request.Form[buttonName];
if (!string.IsNullOrEmpty(value))
{
return(true);
}
}
}
break;
case FormValueRequirement.StartsWith:
{
if (_validateNameOnly)
{
//"name" only
if (routeContext.HttpContext.Request.Form.Keys.Any(x => x.StartsWith(buttonName, StringComparison.InvariantCultureIgnoreCase)))
{
return(true);
}
}
else
{
//validate "value"
foreach (var formValue in routeContext.HttpContext.Request.Form.Keys)
{
if (formValue.StartsWith(buttonName, StringComparison.InvariantCultureIgnoreCase))
{
var value = routeContext.HttpContext.Request.Form[formValue];
if (!string.IsNullOrEmpty(value))
{
return(true);
}
}
}
}
}
break;
}
}
catch (Exception exc)
{
//try-catch to ensure that no exception is throw
Debug.WriteLine(exc.Message);
}
}
return(false);
}
/**
* Create SQL rewrite context.
*
* @param sql SQL
* @param parameters parameters
* @param sqlStatementContext SQL statement context
* @param routeContext route context
* @return SQL rewrite context
*/
public SqlRewriteContext CreateSqlRewriteContext(string sql, ParameterContext parameterContext, ISqlCommandContext <ISqlCommand> sqlCommandContext, RouteContext routeContext)
{
var result = new SqlRewriteContext(_schemaMetaData, sqlCommandContext, sql, parameterContext);
Decorate(_decorators, result, routeContext);
result.GenerateSqlTokens();
return(result);
}
IReadOnlyList <ActionSelectorCandidate> EvaluateActionConstraintsCore(RouteContext context, IReadOnlyList <ActionSelectorCandidate> candidates, int?startingOrder)
{
Contract.Requires(context != null);
Contract.Requires(candidates != null);
var order = default(int?);
for (var i = 0; i < candidates.Count; i++)
{
var candidate = candidates[i];
if (candidate.Constraints == null)
{
continue;
}
for (var j = 0; j < candidate.Constraints.Count; j++)
{
var constraint = candidate.Constraints[j];
if ((startingOrder == null || constraint.Order > startingOrder) && (order == null || constraint.Order < order))
{
order = constraint.Order;
}
}
}
if (order == null)
{
return(candidates);
}
var actionsWithConstraint = new List <ActionSelectorCandidate>();
var actionsWithoutConstraint = new List <ActionSelectorCandidate>();
var constraintContext = new ActionConstraintContext()
{
Candidates = candidates,
RouteContext = context,
};
for (var i = 0; i < candidates.Count; i++)
{
var candidate = candidates[i];
var isMatch = true;
var foundMatchingConstraint = false;
if (candidate.Constraints != null)
{
constraintContext.CurrentCandidate = candidate;
for (var j = 0; j < candidate.Constraints.Count; j++)
{
var constraint = candidate.Constraints[j];
if (constraint.Order != order)
{
continue;
}
foundMatchingConstraint = true;
if (!constraint.Accept(constraintContext))
{
isMatch = false;
Logger.ConstraintMismatch(candidate.Action.DisplayName, candidate.Action.Id, constraint);
break;
}
}
}
if (isMatch && foundMatchingConstraint)
{
actionsWithConstraint.Add(candidate);
}
else if (isMatch)
{
actionsWithoutConstraint.Add(candidate);
}
}
if (actionsWithConstraint.Count > 0)
{
var matches = EvaluateActionConstraintsCore(context, actionsWithConstraint, order);
if (matches?.Count > 0)
{
return(matches);
}
}
if (actionsWithoutConstraint.Count == 0)
{
return(null);
}
else
{
return(EvaluateActionConstraintsCore(context, actionsWithoutConstraint, order));
}
}
private void Decorate(IDictionary <IBaseRule, ISqlRewriteContextDecorator> decorators, SqlRewriteContext sqlRewriteContext, RouteContext routeContext)
{
foreach (var decoratorEntry in decorators)
{
var rule = decoratorEntry.Key;
var decorator = decoratorEntry.Value;
if (decorator is IRouteContextAware routeContextAware)
{
routeContextAware.SetRouteContext(routeContext);
}
decorator.Decorate(rule, _properties, sqlRewriteContext);
}
}
/// <inheritdoc/>
public virtual ActionDescriptor SelectAction(RouteContext routeContext)
{
if (routeContext == null)
{
throw Error.ArgumentNull("routeContext");
}
if (_attributeMappings == null)
{
if (ActionDescriptorCollectionProvider == null)
{
ActionDescriptorCollectionProvider =
routeContext.HttpContext.RequestServices.GetRequiredService <IActionDescriptorCollectionProvider>
();
}
if (ODataPathTemplateHandler == null)
{
ODataPathTemplateHandler =
routeContext.HttpContext.RequestServices.GetRequiredService <IODataPathTemplateHandler>();
}
IEdmModel model = routeContext.HttpContext.ODataFeature().Model;
IEnumerable <ControllerActionDescriptor> actionDescriptors =
ActionDescriptorCollectionProvider.ActionDescriptors.Items.OfType <ControllerActionDescriptor>();
_attributeMappings = BuildAttributeMappings(actionDescriptors, model);
}
HttpRequest request = routeContext.HttpContext.Request;
ODataPath odataPath = routeContext.HttpContext.ODataFeature().Path;
Dictionary <string, object> values = new Dictionary <string, object>();
var routeData = routeContext.RouteData;
var routingConventionsStore = request.ODataFeature().RoutingConventionsStore;
foreach (KeyValuePair <ODataPathTemplate, ControllerActionDescriptor> attributeMapping in _attributeMappings)
{
ODataPathTemplate template = attributeMapping.Key;
ControllerActionDescriptor actionDescriptor = attributeMapping.Value;
if (IsHttpMethodMatch(actionDescriptor, request.Method) && template.TryMatch(odataPath, values))
{
foreach (var item in values)
{
if (item.Key.StartsWith(ODataParameterValue.ParameterValuePrefix, StringComparison.Ordinal) &&
item.Value is ODataParameterValue)
{
routingConventionsStore.Add(item);
}
else
{
routeData.Values.Add(item.Key, item.Value);
}
}
return(actionDescriptor);
}
}
return(null);
}
/// <summary>
/// Create and init the context.
/// </summary>
/// <param name="dbctx"></param>
/// <param name="host"></param>
/// <param name="path"></param>
/// <param name="regionName"></param>
/// <param name="user"></param>
/// <param name="checkInitResults"></param>
/// <returns></returns>
protected async Task <WcmsAppContext> CreateAndInitAppContext(AppDbContext dbctx, string host, string path, string regionName, ApplicationUser user = null, bool checkInitResults = true)
{
// Check the service provider...
Assert.NotEqual(null, _serviceProvider);
// Create and init the http context...
var httpContext = new DefaultHttpContext();
Assert.NotEqual(null, httpContext);
// Configure the http context...
httpContext.RequestServices = _services.BuildServiceProvider();
Assert.NotEqual(null, httpContext.RequestServices);
httpContext.Request.Host = new HostString(host);
httpContext.Request.Path = new PathString(path);
// Add user to the http context...
if (user != null)
{
UserClaimsPrincipalFactory <ApplicationUser, IdentityRole> clmFact
= _GetRequiredServicee <UserClaimsPrincipalFactory <ApplicationUser, IdentityRole> >(httpContext.RequestServices);
Assert.NotEqual(null, clmFact);
httpContext.User = /*ClaimsPrincipal upp =*/ await clmFact.CreateAsync(user);
Assert.NotEqual(null, httpContext.User /*upp*/);
//httpContext.User = new ClaimsPrincipal(upp);
}
// Create and init the route context...
var routeContext = new RouteContext(httpContext);
Assert.NotEqual(null, routeContext);
// Configure the route context...
routeContext.RouteData = new RouteData();
Assert.NotEqual(null, routeContext.RouteData);
routeContext.RouteData.Values.Add(CRoute.RegionTagName, regionName);
// Build loger factory...
var logFactory =
_GetRequiredServicee <ILoggerFactory>(httpContext.RequestServices);
Assert.NotEqual(null, logFactory);
#if DEBUG
//logFactory.AddConsole(_LogFilter);
logFactory.AddDebug(_LogFilter);
#endif
// Create and init the context...
WcmsAppContext ctx =
_GetRequiredServicee <WcmsAppContext>(httpContext.RequestServices);
Assert.NotEqual(null, ctx);
Assert.Equal(null, ctx.User);
Assert.Equal(null, ctx.Site);
//ctx.UnitTestInit(dbctx);
int initSiteAsyncRes = await ctx.InitSiteAsync(httpContext,
_GetRequiredServicee <IAuthorizationService>(httpContext.RequestServices));
bool initRouteAsyncRes = await ctx.InitRouteAsync(routeContext);
if (checkInitResults == true)
{
Assert.Equal(3, initSiteAsyncRes); // No module registered.
Assert.Equal(true, initRouteAsyncRes);
}
return(ctx);
}
/// <summary>
/// Occurs when a single action is matched to the route policy.
/// </summary>
/// <param name="context">The current <see cref="RouteContext">route context</see>.</param>
/// <param name="selectionResult">The current <see cref="ActionSelectionResult">action selection result</see>.</param>
/// <returns>The single, matching <see cref="ActionDescriptor">action</see> conforming to the policy.</returns>
protected virtual ActionDescriptor OnSingleMatch(RouteContext context, ActionSelectionResult selectionResult)
{
Arg.NotNull(context, nameof(context));
Arg.NotNull(selectionResult, nameof(selectionResult));
return(selectionResult.BestMatch);
}
/// <inheritdoc />
protected override Task OnRouteMatched(RouteContext context)
{
context.RouteData.Routers.Add(_target);
return(_target.RouteAsync(context));
}
/// <inheritdoc />
public Task RouteAsync(RouteContext context)
{
var router = GetTreeRouter();
return(router.RouteAsync(context));
}
public async Task <ActionDescriptor> SelectAsync(RouteContext context)
{
return(await Task.FromResult(Select(context)));
}
private string SelectActionImpl(RouteContext routeContext, SelectControllerResult controllerResult, IEnumerable <ControllerActionDescriptor> actionDescriptors)
{
Microsoft.AspNet.OData.Routing.ODataPath odataPath = routeContext.HttpContext.ODataFeature().Path;
HttpRequest request = routeContext.HttpContext.Request;
if (odataPath.PathTemplate == "~/entityset")
{
EntitySetSegment entitySetSegment = (EntitySetSegment)odataPath.Segments[0];
IEdmEntitySetBase entitySet = entitySetSegment.EntitySet;
if (HttpMethods.IsGet(request.Method))
{
// e.g. Try GetCustomers first, then fall back to Get action name
return(actionDescriptors.FindMatchingAction(
"Get" + entitySet.Name,
"Get"));
}
else if (HttpMethods.IsPost(request.Method))
{
// e.g. Try PostCustomer first, then fall back to Post action name
return(actionDescriptors.FindMatchingAction(
"Post" + entitySet.EntityType().Name,
"Post"));
}
}
else if (odataPath.PathTemplate == "~/entityset/key" ||
odataPath.PathTemplate == "~/entityset/key/cast")
{
string httpMethodName;
if (HttpMethods.IsGet(request.Method))
{
httpMethodName = "Get";
}
else if (HttpMethods.IsPut(request.Method))
{
httpMethodName = "Put";
}
else if (HttpMethods.IsPatch(request.Method))
{
httpMethodName = "Patch";
}
else if (HttpMethods.IsDelete(request.Method))
{
httpMethodName = "Delete";
}
else
{
return(null);
}
Contract.Assert(httpMethodName != null);
IEdmEntityType entityType = (IEdmEntityType)odataPath.EdmType;
// e.g. Try GetCustomer first, then fallback on Get action name
string actionName = actionDescriptors.FindMatchingAction(
httpMethodName + entityType.Name,
httpMethodName);
if (actionName != null)
{
KeySegment keySegment = (KeySegment)odataPath.Segments[1];
// TODO: Add key/value to RouteData
return(actionName);
}
}
else if (odataPath.PathTemplate == "~/entityset/$count" &&
HttpMethods.IsGet(request.Method))
{
EntitySetSegment entitySetSegment = (EntitySetSegment)odataPath.Segments[0];
IEdmEntitySetBase entitySet = entitySetSegment.EntitySet;
// e.g. Try GetCustomers first, then fall back to Get action name
return(actionDescriptors.FindMatchingAction(
"Get" + entitySet.Name,
"Get"));
}
else if (odataPath.PathTemplate == "~/entityset/cast")
{
EntitySetSegment entitySetSegment = (EntitySetSegment)odataPath.Segments[0];
IEdmEntitySetBase entitySet = entitySetSegment.EntitySet;
IEdmCollectionType collectionType = (IEdmCollectionType)odataPath.EdmType;
IEdmEntityType entityType = (IEdmEntityType)collectionType.ElementType.Definition;
if (HttpMethods.IsGet(request.Method))
{
// e.g. Try GetCustomersFromSpecialCustomer first, then fall back to GetFromSpecialCustomer
return(actionDescriptors.FindMatchingAction(
"Get" + entitySet.Name + "From" + entityType.Name,
"GetFrom" + entityType.Name));
}
else if (HttpMethods.IsPost(request.Method))
{
// e.g. Try PostCustomerFromSpecialCustomer first, then fall back to PostFromSpecialCustomer
return(actionDescriptors.FindMatchingAction(
"Post" + entitySet.EntityType().Name + "From" + entityType.Name,
"PostFrom" + entityType.Name));
}
}
else if (odataPath.PathTemplate == "~/entityset/cast/$count" &&
HttpMethods.IsGet(request.Method))
{
EntitySetSegment entitySetSegment = (EntitySetSegment)odataPath.Segments[0];
IEdmEntitySetBase entitySet = entitySetSegment.EntitySet;
IEdmCollectionType collectionType = (IEdmCollectionType)odataPath.Segments[1].EdmType;
IEdmEntityType entityType = (IEdmEntityType)collectionType.ElementType.Definition;
// e.g. Try GetCustomersFromSpecialCustomer first, then fall back to GetFromSpecialCustomer
return(actionDescriptors.FindMatchingAction(
"Get" + entitySet.Name + "From" + entityType.Name,
"GetFrom" + entityType.Name));
}
return(null);
}
public async virtual Task RouteAsync(RouteContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
EnsureLoggers(context.HttpContext);
var requestPath = context.HttpContext.Request.Path;
var values = _matcher.Match(requestPath);
if (values == null)
{
// If we got back a null value set, that means the URI did not match
return;
}
var oldRouteData = context.RouteData;
var newRouteData = new RouteData(oldRouteData);
// Perf: Avoid accessing data tokens if you don't need to write to it, these dictionaries are all
// created lazily.
if (_dataTokens.Count > 0)
{
MergeValues(newRouteData.DataTokens, _dataTokens);
}
newRouteData.Routers.Add(_target);
MergeValues(newRouteData.Values, values);
if (!RouteConstraintMatcher.Match(
Constraints,
newRouteData.Values,
context.HttpContext,
this,
RouteDirection.IncomingRequest,
_constraintLogger))
{
return;
}
_logger.LogVerbose(
"Request successfully matched the route with name '{RouteName}' and template '{RouteTemplate}'.",
Name,
RouteTemplate);
try
{
context.RouteData = newRouteData;
await _target.RouteAsync(context);
}
finally
{
// Restore the original values to prevent polluting the route data.
if (!context.IsHandled)
{
context.RouteData = oldRouteData;
}
}
}
public object OnException(RouteContext ctx)
{
return null;
}
public static Task Initialize()
{
return Task.Run(() =>
{
_database = new RailwayDataModelContainer();
Clients = new ClientContext();
Employees = new EmployeeContext();
Stations = new StationContext();
Seats = new SeatContext();
Tickets = new TicketContext();
TrainWagons = new TrainWagonContext();
Trains = new TrainContext();
Routes = new RouteContext();
VoyageRoutes = new VoyageRouteContext();
Voyages = new VoyageContext();
Wagons = new WagonContext();
WagonSeats = new WagonSeatContext();
Clients.Repository = _database.ClientSet;
Employees.Repository = _database.EmployeeSet;
Stations.Repository = _database.StationSet;
Seats.Repository = _database.SeatSet;
Tickets.Repository = _database.TicketSet;
TrainWagons.Repository = _database.TrainWagonSet;
Trains.Repository = _database.TrainSet;
VoyageRoutes.Repository = _database.VoyageRouteSet;
Routes.Repository = _database.RouteSet;
Voyages.Repository = _database.VoyageSet;
Wagons.Repository = _database.WagonSet;
WagonSeats.Repository = _database.WagonSeatSet;
DataBase.Database.Connection.OpenAsync();
});
}
public object BeforeCall(RouteContext ctx)
{
_authProvider.AuthRoute(ctx);
return null;
}
private async Task BatchVariableRequest(RouteContext context)
{
var segments =
context.HttpContext
.Request
.Path
.Value
.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
if (segments.Length == 1 && segments[0] == "variables")
{
using var reader = new StreamReader(context.HttpContext.Request.Body);
var source = await reader.ReadToEndAsync();
var query = JObject.Parse(source);
var response = new JObject();
foreach (var kernelProperty in query.Properties())
{
var kernelName = kernelProperty.Name;
var propertyBag = new JObject();
response[kernelName] = propertyBag;
var targetKernel = GetKernel(kernelName);
if (targetKernel is DotNetKernel languageKernel)
{
foreach (var variableName in kernelProperty.Value.Values <string>())
{
if (languageKernel.TryGetVariable(variableName, out object value))
{
if (value is string)
{
propertyBag[variableName] = JToken.FromObject(value);
}
else
{
propertyBag[variableName] = JToken.Parse(value.ToDisplayString(JsonFormatter.MimeType));
}
}
else
{
context.Handler = async httpContext =>
{
httpContext.Response.StatusCode = 400;
await httpContext.Response.WriteAsync($"variable {variableName} not found on kernel {kernelName}");
await httpContext.Response.CompleteAsync();
};
return;
}
}
}
else
{
context.Handler = async httpContext =>
{
httpContext.Response.StatusCode = 400;
await httpContext.Response.WriteAsync($"kernel {kernelName} not found");
await httpContext.Response.CompleteAsync();
};
return;
}
}
context.Handler = async httpContext =>
{
httpContext.Response.ContentType = JsonFormatter.MimeType;
await using (var writer = new StreamWriter(httpContext.Response.Body))
{
await writer.WriteAsync(response.ToString());
}
await httpContext.Response.CompleteAsync();
};
}
}
public override Boolean IsValidForRequest(RouteContext context, ActionDescriptor action)
{
return(context.HttpContext.Request.Headers["X-Requested-With"] == "XMLHttpRequest");
}
/// <summary>
/// Resolves HTTP request to a route using the provided route context and the action selector and invoker services.
/// </summary>
/// <param name="services">Application services from which the route will be resolved.</param>
/// <param name="router">IRouter to resolve route values.</param>
/// <param name="routeContext">RouteContext to use for resolving the route values.</param>
/// <param name="fullExecution">Indicates whether the full MVC pipeline will be executed or not.</param>
/// <returns>Resolved route information.</returns>
public static ResolvedRouteContext Resolve(
IServiceProvider services,
IRouter router,
RouteContext routeContext,
bool fullExecution = false)
{
try
{
RouteDataResolver.ResolveRouteData(router, routeContext);
}
catch (Exception ex)
{
return(new ResolvedRouteContext($"exception was thrown when trying to resolve route data: '{ex.Unwrap().Message}'"));
}
var actionSelector = services.GetRequiredService <IActionSelector>();
ActionDescriptor actionDescriptor;
try
{
var actions = routeContext
.RouteData
.Routers
.Where(r => r.GetType() == WebFramework.Internals.MvcAttributeRouteHandler)
.FirstOrDefault()
?.Exposed()
.Actions
?? actionSelector.SelectCandidates(routeContext);
actionDescriptor = actionSelector.SelectBestCandidate(
routeContext,
actions);
}
catch (Exception ex)
{
return(new ResolvedRouteContext($"exception was thrown when trying to select an action: '{ex.Unwrap().Message}'"));
}
if (actionDescriptor == null)
{
return(new ResolvedRouteContext("action could not be matched"));
}
routeContext.HttpContext.Features.Set(new RouteTestingFeature(fullExecution));
var actionContext = new ActionContext(routeContext.HttpContext, routeContext.RouteData, actionDescriptor);
if (!(actionDescriptor is ControllerActionDescriptor controllerActionDescriptor))
{
throw new InvalidOperationException("Only controller actions are supported by the route testing.");
}
var actionInvokerFactory = services.GetRequiredService <IActionInvokerFactory>();
var invoker = actionInvokerFactory.CreateInvoker(actionContext);
if (!(invoker is IModelBindingActionInvoker modelBindingActionInvoker))
{
throw new InvalidOperationException($"Route testing requires the selected {nameof(IActionInvoker)} by the {nameof(IActionInvokerFactory)} to implement {nameof(IModelBindingActionInvoker)}.");
}
try
{
AsyncHelper.RunSync(() => modelBindingActionInvoker.InvokeAsync());
}
catch (Exception ex)
{
return(new ResolvedRouteContext($"exception was thrown when trying to invoke the pipeline: '{ex.Unwrap().Message}'"));
}
if (modelBindingActionInvoker.BoundActionArguments == null)
{
var filters = actionDescriptor
.FilterDescriptors
.OrderByDescending(f => f.Order)
.Select(f => $"{f.Filter.GetName()} ({f.Scope.ToFilterScopeName()})");
var filtersMessage = filters != null && filters.Any()
? $"filters - {string.Join(", ", filters)}"
: "filters";
return(new ResolvedRouteContext($"action could not be invoked because of the declared {filtersMessage}. Either a filter is setting the response result before the action itself, or you must set the request properties so that they will pass through the pipeline"));
}
return(new ResolvedRouteContext(
controllerActionDescriptor.ControllerTypeInfo,
controllerActionDescriptor.ControllerName,
controllerActionDescriptor.ActionName,
modelBindingActionInvoker.BoundActionArguments,
actionContext.RouteData,
actionContext.ModelState));
}
public Task RouteAsync(RouteContext context)
{
if (MatchingDelegate == null)
{
context.Handler = NullHandler;
}
else
{
context.Handler = MatchingDelegate(context) ? NullHandler : null;
}
return Task.FromResult(true);
}
public TelefoneRepository(RouteContext context) : base(context)
{
}
/// <summary>
/// Route request to the particular action
/// </summary>
/// <param name="context">A route context object</param>
/// <returns>Task of the routing</returns>
public override Task RouteAsync(RouteContext context)
{
if (!DataSettingsHelper.DatabaseIsInstalled())
{
return(Task.CompletedTask);
}
//try to get slug from the route data
var routeValues = GetRouteValues(context);
if (!routeValues.TryGetValue("GenericSeName", out object slugValue) || string.IsNullOrEmpty(slugValue as string))
{
return(Task.CompletedTask);
}
var slug = slugValue as string;
//performance optimization, we load a cached verion here. It reduces number of SQL requests for each page load
var urlRecordService = EngineContext.Current.Resolve <IUrlRecordService>();
var urlRecord = urlRecordService.GetBySlugCached(slug);
//comment the line above and uncomment the line below in order to disable this performance "workaround"
//var urlRecord = urlRecordService.GetBySlug(slug);
//no URL record found
if (urlRecord == null)
{
return(Task.CompletedTask);
}
//virtual directory path
var pathBase = context.HttpContext.Request.PathBase;
//if URL record is not active let's find the latest one
if (!urlRecord.IsActive)
{
var activeSlug = urlRecordService.GetActiveSlug(urlRecord.EntityId, urlRecord.EntityName, urlRecord.LanguageId);
if (string.IsNullOrEmpty(activeSlug))
{
return(Task.CompletedTask);
}
//redirect to active slug if found
var redirectionRouteData = new RouteData(context.RouteData);
redirectionRouteData.Values["controller"] = "Common";
redirectionRouteData.Values["action"] = "InternalRedirect";
redirectionRouteData.Values["url"] = $"{pathBase}/{activeSlug}{context.HttpContext.Request.QueryString}";
redirectionRouteData.Values["permanentRedirect"] = true;
context.HttpContext.Items["nop.RedirectFromGenericPathRoute"] = true;
context.RouteData = redirectionRouteData;
return(_target.RouteAsync(context));
}
//ensure that the slug is the same for the current language,
//otherwise it can cause some issues when customers choose a new language but a slug stays the same
var workContext = EngineContext.Current.Resolve <IWorkContext>();
var slugForCurrentLanguage = SeoExtensions.GetSeName(urlRecord.EntityId, urlRecord.EntityName, workContext.WorkingLanguage.Id);
if (!string.IsNullOrEmpty(slugForCurrentLanguage) && !slugForCurrentLanguage.Equals(slug, StringComparison.InvariantCultureIgnoreCase))
{
//we should make validation above because some entities does not have SeName for standard (Id = 0) language (e.g. news, blog posts)
//redirect to the page for current language
var redirectionRouteData = new RouteData(context.RouteData);
redirectionRouteData.Values["controller"] = "Common";
redirectionRouteData.Values["action"] = "InternalRedirect";
redirectionRouteData.Values["url"] = $"{pathBase}/{slugForCurrentLanguage}{context.HttpContext.Request.QueryString}";
redirectionRouteData.Values["permanentRedirect"] = false;
context.HttpContext.Items["nop.RedirectFromGenericPathRoute"] = true;
context.RouteData = redirectionRouteData;
return(_target.RouteAsync(context));
}
//since we are here, all is ok with the slug, so process URL
var currentRouteData = new RouteData(context.RouteData);
switch (urlRecord.EntityName.ToLowerInvariant())
{
case "product":
currentRouteData.Values["controller"] = "Product";
currentRouteData.Values["action"] = "ProductDetails";
currentRouteData.Values["productid"] = urlRecord.EntityId;
currentRouteData.Values["SeName"] = urlRecord.Slug;
break;
case "category":
currentRouteData.Values["controller"] = "Catalog";
currentRouteData.Values["action"] = "Category";
currentRouteData.Values["categoryid"] = urlRecord.EntityId;
currentRouteData.Values["SeName"] = urlRecord.Slug;
break;
case "manufacturer":
currentRouteData.Values["controller"] = "Catalog";
currentRouteData.Values["action"] = "Manufacturer";
currentRouteData.Values["manufacturerid"] = urlRecord.EntityId;
currentRouteData.Values["SeName"] = urlRecord.Slug;
break;
case "vendor":
currentRouteData.Values["controller"] = "Catalog";
currentRouteData.Values["action"] = "Vendor";
currentRouteData.Values["vendorid"] = urlRecord.EntityId;
currentRouteData.Values["SeName"] = urlRecord.Slug;
break;
case "newsitem":
currentRouteData.Values["controller"] = "News";
currentRouteData.Values["action"] = "NewsItem";
currentRouteData.Values["newsItemId"] = urlRecord.EntityId;
currentRouteData.Values["SeName"] = urlRecord.Slug;
break;
case "blogpost":
currentRouteData.Values["controller"] = "Blog";
currentRouteData.Values["action"] = "BlogPost";
currentRouteData.Values["blogPostId"] = urlRecord.EntityId;
currentRouteData.Values["SeName"] = urlRecord.Slug;
break;
case "topic":
currentRouteData.Values["controller"] = "Topic";
currentRouteData.Values["action"] = "TopicDetails";
currentRouteData.Values["topicId"] = urlRecord.EntityId;
currentRouteData.Values["SeName"] = urlRecord.Slug;
break;
default:
//no record found, thus generate an event this way developers could insert their own types
EngineContext.Current.Resolve <IEventPublisher>().Publish(new CustomUrlRecordEntityNameRequested(currentRouteData, urlRecord));
break;
}
context.RouteData = currentRouteData;
//route request
return(_target.RouteAsync(context));
}
public void AfterCall(RouteContext ctx)
{
_uow?.Commit();
}
