internal MapRouteBuilder Register(string urlTemplate, string method, HandlerFunc handler)
{
if (string.IsNullOrWhiteSpace(method))
{
throw new ArgumentNullException("method");
}
if (string.IsNullOrWhiteSpace(urlTemplate))
{
throw new ArgumentNullException("urlTemplate");
}
if (handler == null)
{
throw new ArgumentNullException("handler");
}
var segments = RouteBuilderHelper.GetUrlTemplateSegments(urlTemplate);
var route = new Route
{
Method = method,
Segments = segments,
Handler = handler
};
_routes.Add(route);
return(this);
}
public void Put(
string urlPattern,
MiddlewareFunc middlewareFunc,
HandlerFunc handler)
{
Put(urlPattern, new[] { middlewareFunc }, (environment, @params, next) => handler(environment, next));
}
public void AddHandler(string url, HttpMethod method, HandlerFunc handler)
{
if (string.IsNullOrEmpty(url) || (url.Length == 1 && url[0] == '/'))
{
_pathTree.Add(method, handler);
return;
}
if (url[0] == '/')
{
url = url.Substring(1);
}
string[] path = url.Split('/');
PathTreeNode finiteNode = _pathTree;
foreach (var segment in path)
{
if (finiteNode.TryGetSubNode(segment, out PathTreeNode sub))
{
if (sub != null)
{
finiteNode = sub;
}
}
else
{
finiteNode = finiteNode.Add(segment);
}
}
finiteNode.Add(method, handler);
}
public bool TryGetHandler(HttpListenerRequest request, out HandlerFunc handler)
{
string[] segments = request.Url.AbsolutePath.Split('/');
var finiteNode = _pathTree;
for (int i = 1; i < segments.Length; i++)
{
if (finiteNode.TryGetSubNode(segments[i], out PathTreeNode sub))
{
finiteNode = sub;
}
else
{
foreach (var pattern in _parameterMapping)
{
if (pattern.Value.IsMatch(segments[i]))
{
segments[i] = pattern.Key;
break;
}
}
if (finiteNode.TryGetSubNode(segments[i], out sub))
{
finiteNode = sub;
}
}
}
return(finiteNode.TryGetHandler(request.HttpMethod, out handler));
}
public void Delete(
string urlPattern,
MiddlewareFunc[] middlewareFuncs,
HandlerFunc handlerFunc)
{
Delete(urlPattern, middlewareFuncs, (environment, @params, next) => handlerFunc(environment, next));
}
public HandlerFunc AuthMiddleware(HandlerFunc next)
{
return((context) =>
{
next(context);
});
}
internal RouteBuilder Register(string method, HandlerFunc handler)
{
if (handler == null)
{
throw new ArgumentNullException("handler");
}
return(Register(method, (ctx, _) => handler(ctx)));
}
public HandlerFunc LogMiddleware(HandlerFunc next)
{
return((context) =>
{
var rq = context.Request;
var method = rq.HttpMethod;
var pattern = rq.Url.LocalPath;
var stopwatch = new Stopwatch();
stopwatch.Start();
next(context);
stopwatch.Stop();
var log = string.Format("Method: {0}, Pattern: {1} - {2} ms", method, pattern, stopwatch.ElapsedMilliseconds.ToString());
Console.WriteLine(log);
});
}
public HandlerFunc CorsMiddleware(HandlerFunc next)
{
return((context) =>
{
var response = context.Response;
response.Headers.Add("Access-Control-Allow-Origin", "*");
response.Headers.Add("Access-Control-Allow-Methods", "OPTIONS, POST, GET");
response.Headers.Add("Access-Control-Allow-Headers", "Content-type");
if (context.Request.HttpMethod.Equals("OPTIONS"))
{
response.StatusCode = 207;
response.OutputStream.Close();
return;
}
next(context);
});
}
public void RegisterAsset(string type, string subtype, string[] fileExtensions, HandlerFunc handler)
{
if (AssetHandlers.ContainsKey(type) && AssetHandlers[type].ContainsKey(subtype))
{
throw new Exception($"Registering duplicate handler for {type}/{subtype}");
}
if (!AssetHandlers.ContainsKey(type))
{
AssetHandlers[type] = new Dictionary <string, HandlerFunc>();
}
foreach (var fileExtension in fileExtensions)
{
if (FileExtensionAssetTypes.ContainsKey(fileExtension))
{
throw new Exception($"Registering duplicate handler for asset type with file extension {fileExtension}");
}
FileExtensionAssetTypes[fileExtension] = type + "/" + subtype;
}
AssetHandlers[type][subtype] = handler;
}
/// <summary>
/// Registers POST handler.
/// </summary>
/// <param name="app"></param>
/// <param name="url"></param>
/// <param name="handler"></param>
/// <returns></returns>
public static IAppBuilder Post(this IAppBuilder app, string url, HandlerFunc handler)
{
app.Route(url).Post(handler);
return(app);
}
public void RegisterAssetType(string assetType, string[] fileExtensions, HandlerFunc handler)
{
string[] types = SplitAssetType(assetType);
RegisterAsset(types[0], types[1], fileExtensions, handler);
}
/// <summary>
/// Registers PATCH handler.
/// </summary>
/// <param name="handler">The handler to register.</param>
public RouteBuilder Patch(HandlerFunc handler)
{
return(Register(HttpMethod.Patch, handler));
}
public RouteBuilder Update(HandlerFunc handler)
{
return(Register("UPDATE", handler));
}
public bool TryGetHandler(string method, out HandlerFunc handler)
{
var httpMethod = new HttpMethod(method);
return(_handlerFunctions.TryGetValue(httpMethod, out handler));
}
public void Add(HttpMethod method, HandlerFunc handler)
{
_handlerFunctions.Add(method, handler);
}
/// <summary>
/// Registers DELETE handler.
/// </summary>
/// <param name="handler">The handler to register.</param>
public RouteBuilder Delete(HandlerFunc handler)
{
return(Register(HttpMethod.Delete, handler));
}
/// <summary>
/// Registers POST handler.
/// </summary>
/// <param name="handler">The handler to register.</param>
public RouteBuilder Post(HandlerFunc handler)
{
return(Register(HttpMethod.Post, handler));
}
public static void RegisterAssetType(string type, string subtype, string[] fileExtensions, HandlerFunc handler)
{
using var _ = ApiCallSource.StartExternalCall();
RegisterAssetTypeInner(type, subtype, fileExtensions, handler);
}
internal static void RegisterAssetTypeInner(string type, string subtype, string[] fileExtensions, HandlerFunc handler)
{
InnerInstance.RegisterAsset(type, subtype, fileExtensions, handler);
}
public void InstallHandler(string name, HandlerFunc func)
{
dict["/" + name] = func;
}
public void InstallHandler(string name, HandlerFunc func)
{
dict["/" + name] = func;
}
public void Put(
string urlPattern,
HandlerFunc handlerFunc)
{
Put(urlPattern, new MiddlewareFunc[0], (environment, @params, next) => handlerFunc(environment, next));
}
