public static IEndpointConventionBuilder MapGraphQL(
this IEndpointRouteBuilder endpointRouteBuilder,
PathString path,
NameString schemaName = default)
{
if (endpointRouteBuilder is null)
{
throw new ArgumentNullException(nameof(endpointRouteBuilder));
}
path = path.ToString().TrimEnd('/');
RoutePattern pattern = RoutePatternFactory.Parse(path + "/{**slug}");
IApplicationBuilder requestPipeline = endpointRouteBuilder.CreateApplicationBuilder();
NameString schemaNameOrDefault = schemaName.HasValue ? schemaName : Schema.DefaultName;
IFileProvider fileProvider = CreateFileProvider();
requestPipeline.UseMiddleware <WebSocketSubscriptionMiddleware>(schemaNameOrDefault);
requestPipeline.UseMiddleware <HttpPostMiddleware>(schemaNameOrDefault);
requestPipeline.UseMiddleware <HttpGetSchemaMiddleware>(schemaNameOrDefault);
requestPipeline.UseMiddleware <ToolDefaultFileMiddleware>(fileProvider, path);
requestPipeline.UseMiddleware <ToolStaticFileMiddleware>(fileProvider, path);
requestPipeline.UseMiddleware <HttpGetMiddleware>(schemaNameOrDefault);
return(endpointRouteBuilder
.Map(pattern, requestPipeline.Build())
.WithDisplayName("Hot Chocolate GraphQL Pipeline"));
}
public void CreatePattern(string contentType, string name, string pattern, string description, bool makeDefault)
{
var contentDefinition = _contentDefinitionManager.GetTypeDefinition(contentType);
if (contentDefinition == null)
{
throw new OrchardException(T("Unknown content type: {0}", contentType));
}
var settings = contentDefinition.Settings.GetModel <AutorouteSettings>();
var routePattern = new RoutePattern {
Description = description,
Name = name,
Pattern = pattern,
Culture = _cultureManager.GetSiteCulture()
};
var patterns = settings.Patterns;
patterns.Add(routePattern);
settings.Patterns = patterns;
// Define which pattern is the default.
if (makeDefault || settings.Patterns.Count == 1)
{
settings.DefaultPatterns = new List <DefaultPattern> {
new DefaultPattern {
PatternIndex = "0", Culture = settings.Patterns[0].Culture
}
};
}
_contentDefinitionManager.AlterTypeDefinition(contentType, builder => builder.WithPart("AutoroutePart", settings.Build));
}
public ConventionalRouteEntry(
string routeName,
string pattern,
RouteValueDictionary defaults,
IDictionary <string, object> constraints,
RouteValueDictionary dataTokens)
{
RouteName = routeName;
DataTokens = dataTokens;
try
{
// Data we parse from the pattern will be used to fill in the rest of the constraints or
// defaults. The parser will throw for invalid routes.
Pattern = RoutePatternFactory.Parse(pattern, defaults, constraints);
}
catch (Exception exception)
{
throw new RouteCreationException(string.Format(
CultureInfo.CurrentCulture,
"An error occurred while creating the route with name '{0}' and pattern '{1}'.",
routeName,
pattern), exception);
}
}
public RouteTemplate(RoutePattern other)
{
if (other == null)
{
throw new ArgumentNullException(nameof(other));
}
// RequiredValues will be ignored. RouteTemplate doesn't support them.
TemplateText = other.RawText;
Segments = new List <TemplateSegment>(other.PathSegments.Select(p => new TemplateSegment(p)));
Parameters = new List <TemplatePart>();
for (var i = 0; i < Segments.Count; i++)
{
var segment = Segments[i];
for (var j = 0; j < segment.Parts.Count; j++)
{
var part = segment.Parts[j];
if (part.IsParameter)
{
Parameters.Add(part);
}
}
}
}
public IEndpointConventionBuilder MapFallback(RoutePattern pattern, RequestDelegate requestDelegate)
{
return(MapRequestDelegate(pattern, requestDelegate)
.WithDisplayName("Fallback " + pattern)
.WithMetadata(TrackAvailabilityMetadata.Fallback)
.WithDefaults(a => a.Add(b => ((RouteEndpointBuilder)b).Order = int.MaxValue)));
}
public static RSocketEndpointConventionBuilder MapRSocket(
this IEndpointRouteBuilder routeBuilder,
RoutePattern pattern,
Action <HttpConnectionDispatcherOptions> configureOptions)
{
return(MapRSocketInternal(routeBuilder, pattern, configureOptions));
}
public async Task AddRoutePatternToClaims()
{
var context = new DefaultHttpContext();
context.Request.Method = "POST";
IEndpointFeature endpointFeature = Substitute.For <IEndpointFeature>();
RoutePattern routePattern = RoutePatternFactory.Pattern("weather/{town}");
var routeEndpoint = new RouteEndpoint(_ => null, routePattern, default, default, string.Empty);
public Mapping(RoutePattern pattern, Type controllerType, MethodCallExpression method)
{
Pattern = pattern;
ControllerType = controllerType;
Method = method;
Builder = new ConventionBuilder();
}
public static IEndpointConventionBuilder Map(
this IEndpointRouteBuilder builder,
RoutePattern pattern,
RequestDelegate requestDelegate,
params object[] metadata)
{
return(Map(builder, pattern, pattern.RawText ?? pattern.DebuggerToString(), requestDelegate, metadata));
}
public static MatcherEndpointBuilder MapEndpoint(
this EndpointDataSourceBuilder builder,
RequestDelegate requestDelegate,
RoutePattern pattern,
string displayName)
{
return(MapEndpoint(builder, requestDelegate, pattern, displayName, metadata: null));
}
/// <summary>
/// Downloads static Connexionz Route (e.g. Route 1, Route 8, etc) info.
/// </summary>
public static List <ConnexionzRoute> LoadRoutes()
{
RoutePattern routePattern = GetEntity <RoutePattern>(BASE_URL + "&Name=RoutePattern.rxml");
var routePatternProject = routePattern.Items.Skip(1).FirstOrDefault() as RoutePatternProject;
return(routePatternProject.Route.Select(r => new ConnexionzRoute(r)).ToList());
}
/// <summary>
/// Adds a <see cref="RouteEndpoint"/> to the <see cref="IEndpointRouteBuilder"/> that matches HTTP requests
/// for the specified pattern.
/// </summary>
/// <param name="endpoints">The <see cref="IEndpointRouteBuilder"/> to add the route to.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="action">The delegate executed when the endpoint is matched.</param>
/// <returns>A <see cref="IEndpointConventionBuilder"/> that can be used to further customize the endpoint.</returns>
public static MinimalActionEndpointConventionBuilder Map(
this IEndpointRouteBuilder endpoints,
RoutePattern pattern,
Delegate action)
{
if (endpoints is null)
{
throw new ArgumentNullException(nameof(endpoints));
}
if (pattern is null)
{
throw new ArgumentNullException(nameof(pattern));
}
if (action is null)
{
throw new ArgumentNullException(nameof(action));
}
const int defaultOrder = 0;
var builder = new RouteEndpointBuilder(
RequestDelegateFactory.Create(action, endpoints.ServiceProvider),
pattern,
defaultOrder)
{
DisplayName = pattern.RawText ?? pattern.DebuggerToString(),
};
// REVIEW: Should we add an IActionMethodMetadata with just MethodInfo on it so we are
// explicit about the MethodInfo representing the "action" and not the RequestDelegate?
// Add MethodInfo as metadata to assist with OpenAPI generation for the endpoint.
builder.Metadata.Add(action.Method);
// Add delegate attributes as metadata
var attributes = action.Method.GetCustomAttributes();
// This can be null if the delegate is a dynamic method or compiled from an expression tree
if (attributes is not null)
{
foreach (var attribute in attributes)
{
builder.Metadata.Add(attribute);
}
}
var dataSource = endpoints.DataSources.OfType <ModelEndpointDataSource>().FirstOrDefault();
if (dataSource is null)
{
dataSource = new ModelEndpointDataSource();
endpoints.DataSources.Add(dataSource);
}
return(new MinimalActionEndpointConventionBuilder(dataSource.AddEndpointBuilder(builder)));
}
public MethodModel(
RoutePattern pattern,
IList <object> metadata,
RequestDelegate requestDelegate)
{
Pattern = pattern;
Metadata = metadata;
RequestDelegate = requestDelegate;
}
public MatcherEndpointBuilder(
Func <RequestDelegate, RequestDelegate> invoker,
RoutePattern routePattern,
int order)
{
Invoker = invoker;
RoutePattern = routePattern;
Order = order;
}
public RoutePatternBinder Create(RoutePattern pattern)
{
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern));
}
return(Create(pattern, new DispatcherValueCollection()));
}
/// <summary>
/// Constructs new instance of EnpointInfo
/// </summary>
/// <param name="type">Type of IEndpoint</param>
/// <param name="handlerDeclaration">Information about the endpoint handler</param>
/// <param name="pattern">Route pattern of endpoint</param>
/// <param name="name">Route Name</param>
/// <param name="order">Route order.</param>
public EndpointDeclaration(Type type, EndpointRequestHandlerDeclaration handlerDeclaration, RoutePattern pattern, string name, int order)
{
Type = type;
HandlerDeclaration = handlerDeclaration;
Pattern = pattern;
Order = order;
Name = name;
Meta = new List <object>();
}
public RouteEndpointBuilder(
RequestDelegate requestDelegate,
RoutePattern routePattern,
int order)
{
RequestDelegate = requestDelegate;
RoutePattern = routePattern;
Order = order;
}
public override RoutePattern SubstituteRequiredValues(RoutePattern original, object requiredValues)
{
if (original == null)
{
throw new ArgumentNullException(nameof(original));
}
return(SubstituteRequiredValues(original, new RouteValueDictionary(requiredValues)));
}
internal Cache CreateCache()
{
var endpoints = GetEndpoints();
var groups = new Dictionary <Key, List <Endpoint> >();
for (var i = 0; i < endpoints.Count; i++)
{
var endpoint = endpoints[i];
var templateEndpoint = endpoint as IRoutePatternEndpoint;
if (templateEndpoint == null)
{
continue;
}
var order = endpoint.Metadata?.GetMetadata <IEndpointOrderMetadata>()?.Order ?? 0;
if (!groups.TryGetValue(new Key(order, templateEndpoint.Pattern), out var group))
{
group = new List <Endpoint>();
groups.Add(new Key(order, templateEndpoint.Pattern), group);
}
group.Add(endpoint);
}
var entries = new List <InboundRouteEntry>();
foreach (var group in groups)
{
var routePattern = RoutePattern.Parse(group.Key.RoutePattern);
var entryExists = entries.Any(item => item.RoutePattern.RawText == routePattern.RawText);
if (!entryExists)
{
entries.Add(MapInbound(routePattern, group.Value.ToArray(), group.Key.Order));
}
}
var trees = new List <UrlMatchingTree>();
for (var i = 0; i < entries.Count; i++)
{
var entry = entries[i];
while (trees.Count <= entry.Order)
{
trees.Add(new UrlMatchingTree(entry.Order));
}
var tree = trees[entry.Order];
UrlMatchingTree.AddEntryToTree(tree, entry);
}
return(new Cache(trees.ToArray()));
}
/// <summary>
/// Adds a <see cref="RouteEndpoint"/> to the <see cref="IEndpointRouteBuilder"/> that matches HTTP requests
/// for the specified pattern.
/// </summary>
/// <param name="builder">The <see cref="IEndpointRouteBuilder"/> to add the route to.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="displayName">The display name for the endpoint.</param>
/// <param name="requestDelegate">The delegate executed when the endpoint is matched.</param>
/// <param name="metadata">Metadata that is added to the endpoint.</param>
/// <returns>A <see cref="IEndpointConventionBuilder"/> that can be used to further customize the endpoint.</returns>
public static IEndpointConventionBuilder Map(
this IEndpointRouteBuilder builder,
RoutePattern pattern,
string displayName,
RequestDelegate requestDelegate,
params object[] metadata)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern));
}
if (requestDelegate == null)
{
throw new ArgumentNullException(nameof(requestDelegate));
}
const int defaultOrder = 0;
var routeEndpointBuilder = new RouteEndpointBuilder(
requestDelegate,
pattern,
defaultOrder)
{
DisplayName = displayName
};
// Add delegate attributes as metadata
foreach (var attribute in requestDelegate.Method.GetCustomAttributes())
{
routeEndpointBuilder.Metadata.Add(attribute);
}
if (metadata != null)
{
foreach (var item in metadata)
{
routeEndpointBuilder.Metadata.Add(item);
}
}
var modelEndpointDataSource = builder.DataSources.OfType <ModelEndpointDataSource>().FirstOrDefault();
if (modelEndpointDataSource == null)
{
modelEndpointDataSource = new ModelEndpointDataSource();
builder.DataSources.Add(modelEndpointDataSource);
}
return(modelEndpointDataSource.AddEndpointBuilder(routeEndpointBuilder));
}
/// <summary>
/// Constructs a new <see cref="RouteGroupContext"/> instance.
/// </summary>
/// <param name="prefix">The full group prefix. See <see cref="Prefix"/>.</param>
/// <param name="conventions">All conventions added to a parent group. See <see cref="Conventions"/>.</param>
/// <param name="applicationServices">Application services. See <see cref="ApplicationServices"/>.</param>
public RouteGroupContext(RoutePattern prefix, IReadOnlyList <Action <EndpointBuilder> > conventions, IServiceProvider applicationServices)
{
ArgumentNullException.ThrowIfNull(prefix);
ArgumentNullException.ThrowIfNull(conventions);
ArgumentNullException.ThrowIfNull(applicationServices);
Prefix = prefix;
Conventions = conventions;
ApplicationServices = applicationServices;
}
// TODO wrap these into configuration via json or something better
public static IEndpointDataSourceBuilder AddProxyEndpoint(this IEndpointDataSourceBuilder builder,
RoutePattern routePattern,
RouteValueDictionary requiredValues,
int order,
EndpointMetadataCollection metadata,
string displayName,
Uri matchUri)
{
builder.Endpoints.Add(new ProxyEndpoint(routePattern, requiredValues, order, metadata, displayName, matchUri));
return(builder);
}
public ConventionalRouteEntry(RoutePattern pattern, string routeName, RouteValueDictionary dataTokens)
{
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern));
}
Pattern = pattern;
RouteName = routeName;
DataTokens = dataTokens;
}
public DefaultEndpointConventionBuilder(RoutePattern routePattern, RequestDelegate requestDelegate)
{
_conventions = new List <Action <EndpointBuilder> >();
_routePattern = routePattern;
_displayName = routePattern.RawText ?? "null";
_requestDelegate = requestDelegate;
// Add delegate attributes as metadata
// This can be null if the delegate is a dynamic method or compiled from an expression tree
_metadata = new List <object>(requestDelegate.Method?.GetCustomAttributes() ?? Enumerable.Empty <Attribute>());
}
/// <summary>
/// Adds a <see cref="RouteEndpoint"/> to the <see cref="IEndpointRouteBuilder"/> that matches HTTP requests
/// for the specified pattern.
/// </summary>
/// <param name="endpoints">The <see cref="IEndpointRouteBuilder"/> to add the route to.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="action">The delegate executed when the endpoint is matched.</param>
/// <returns>A <see cref="IEndpointConventionBuilder"/> that can be used to further customize the endpoint.</returns>
public static MinimalActionEndpointConventionBuilder Map(
this IEndpointRouteBuilder endpoints,
RoutePattern pattern,
Delegate action)
{
if (endpoints is null)
{
throw new ArgumentNullException(nameof(endpoints));
}
if (pattern is null)
{
throw new ArgumentNullException(nameof(pattern));
}
if (action is null)
{
throw new ArgumentNullException(nameof(action));
}
const int defaultOrder = 0;
var builder = new RouteEndpointBuilder(
RequestDelegateFactory.Create(action),
pattern,
defaultOrder)
{
DisplayName = pattern.RawText ?? pattern.DebuggerToString(),
};
// Add delegate attributes as metadata
var attributes = action.Method.GetCustomAttributes();
// This can be null if the delegate is a dynamic method or compiled from an expression tree
if (attributes is not null)
{
foreach (var attribute in attributes)
{
builder.Metadata.Add(attribute);
}
}
var dataSource = endpoints.DataSources.OfType <ModelEndpointDataSource>().FirstOrDefault();
if (dataSource is null)
{
dataSource = new ModelEndpointDataSource();
endpoints.DataSources.Add(dataSource);
}
return(new MinimalActionEndpointConventionBuilder(dataSource.AddEndpointBuilder(builder)));
}
public static RouteEndpoint CreateRouteEndpoint(
RoutePattern routePattern = null,
int order = 0,
string displayName = null,
IList <object> metadata = null)
{
return(new RouteEndpoint(
TestConstants.EmptyRequestDelegate,
routePattern,
order,
new EndpointMetadataCollection(metadata ?? Array.Empty <object>()),
displayName));
}
private string GetRouteArea(RoutePattern route, out bool isParameter)
{
string area = null;
isParameter = route.Parameters.Any(p => p.Name.Equals("area"));
if (route.Defaults.TryGetValue("area", out var areaObj))
{
return(areaObj.ToString());
}
return(area);
}
private string GetRouteController(RoutePattern route, out bool isParameter)
{
var controller = string.Empty;
isParameter = route.Parameters.Any(p => p.Name.Equals("controller"));
if (route.Defaults.TryGetValue("controller", out var controllerObj))
{
return(WithSuffix(controllerObj.ToString(), "Controller"));
}
return(controller);
}
private string GetRouteAction(RoutePattern route, out bool isParameter)
{
var action = string.Empty;
isParameter = route.Parameters.Any(p => p.Name.Equals("action"));
if (route.Defaults.TryGetValue("action", out var controllerObj))
{
return(controllerObj.ToString());
}
return(action);
}
/// <summary>
/// Generates an OData link using the given OData route name, path handler, and segments.
/// </summary>
/// <param name="request">The Http request.</param>
/// <param name="segments">The OData path segments.</param>
/// <returns>The generated OData link.</returns>
public static string CreateODataLink(this HttpRequest request, IList <ODataPathSegment> segments)
{
if (request == null)
{
throw Error.ArgumentNull(nameof(request));
}
IODataFeature oDataFeature = request.ODataFeature();
string odataPath = segments.GetPathString();
// retrieve the cached base address
string baseAddress = oDataFeature.BaseAddress;
if (baseAddress != null)
{
return(CombinePath(baseAddress, odataPath));
}
// if no, calculate the base address
string uriString = UriHelper.BuildAbsolute(request.Scheme, request.Host, request.PathBase);
string prefix = oDataFeature.RoutePrefix;
if (string.IsNullOrEmpty(prefix))
{
baseAddress = uriString;
}
else
{
// Construct the prefix template if it's a template
RoutePattern routePattern = RoutePatternFactory.Parse(prefix);
if (!routePattern.Parameters.Any())
{
baseAddress = CombinePath(uriString, prefix);
}
else
{
if (TryProcessPrefixTemplate(request, routePattern, out var path))
{
baseAddress = CombinePath(uriString, path);
}
else
{
throw new ODataException(Error.Format(SRResources.CannotProcessPrefixTemplate, prefix));
}
}
}
// cache the base address
oDataFeature.BaseAddress = baseAddress;
return(CombinePath(baseAddress, odataPath));
}
