public void RegisterRestPaths(Type requestType)
{
var attrs = TypeDescriptor.GetAttributes(requestType).OfType <RouteAttribute>();
foreach (RouteAttribute attr in attrs)
{
var restPath = new RestPath(requestType, attr.Path, attr.Verbs, attr.Summary, attr.Notes);
var defaultAttr = attr as FallbackRouteAttribute;
if (defaultAttr != null)
{
if (EndpointHost.Config != null)
{
if (EndpointHost.Config.FallbackRestPath != null)
{
throw new NotSupportedException(string.Format(
"Config.FallbackRestPath is already defined. Only 1 [FallbackRoute] is allowed."));
}
EndpointHost.Config.FallbackRestPath = (httpMethod, pathInfo, filePath) =>
{
var pathInfoParts = RestPath.GetPathPartsForMatching(pathInfo);
return(restPath.IsMatch(httpMethod, pathInfoParts) ? restPath : null);
};
}
continue;
}
if (!restPath.IsValid)
{
throw new NotSupportedException(string.Format(
"RestPath '{0}' on Type '{1}' is not Valid", attr.Path, requestType.Name));
}
RegisterRestPath(restPath);
}
}
public void RegisterRestPath(RestPath restPath)
{
if (!EndpointHostConfig.SkipRouteValidation)
{
if (!restPath.Path.StartsWith("/"))
{
throw new ArgumentException("Route '{0}' on '{1}' must start with a '/'".Fmt(restPath.Path, restPath.RequestType.Name));
}
if (restPath.Path.IndexOfAny(InvalidRouteChars) != -1)
{
throw new ArgumentException(("Route '{0}' on '{1}' contains invalid chars. " +
"See https://github.com/SStack/SStack/wiki/Routing for info on valid routes.").Fmt(restPath.Path, restPath.RequestType.Name));
}
}
List <RestPath> pathsAtFirstMatch;
if (!RestPathMap.TryGetValue(restPath.FirstMatchHashKey, out pathsAtFirstMatch))
{
pathsAtFirstMatch = new List <RestPath>();
RestPathMap[restPath.FirstMatchHashKey] = pathsAtFirstMatch;
}
pathsAtFirstMatch.Add(restPath);
}
private MethodDescription FormateMethodDescription(RestPath restPath, Dictionary<string, SwaggerModel> models)
{
var verbs = new List<string>();
var summary = restPath.Summary;
var notes = restPath.Notes;
if (restPath.AllowsAllVerbs)
{
verbs.AddRange(new[] { "GET", "POST", "PUT", "DELETE" });
}
else
verbs.AddRange(restPath.AllowedVerbs.Split(new[] { ',', ' ' }, StringSplitOptions.RemoveEmptyEntries));
var nickName = nicknameCleanerRegex.Replace(restPath.Path, "");
var md = new MethodDescription
{
Path = restPath.Path,
Description = summary,
Operations = verbs.Select(verb =>
new MethodOperation
{
HttpMethod = verb,
Nickname = verb.ToLowerInvariant() + nickName,
Summary = summary,
Notes = notes,
Parameters = ParseParameters(verb, restPath.RequestType, models),
ResponseClass = GetResponseClass(restPath, models),
ErrorResponses = GetMethodResponseCodes(restPath.RequestType)
}).ToList()
};
return md;
}
public IRestPath GetRestPathForRequest(string httpMethod, string pathInfo)
{
var matchUsingPathParts = RestPath.GetPathPartsForMatching(pathInfo);
List <RestPath> firstMatches;
var yieldedHashMatches = RestPath.GetFirstMatchHashKeys(matchUsingPathParts);
foreach (var potentialHashMatch in yieldedHashMatches)
{
if (!this.RestPathMap.TryGetValue(potentialHashMatch, out firstMatches))
{
continue;
}
var bestScore = -1;
foreach (var restPath in firstMatches)
{
var score = restPath.MatchScore(httpMethod, matchUsingPathParts);
if (score > bestScore)
{
bestScore = score;
}
}
if (bestScore > 0)
{
foreach (var restPath in firstMatches)
{
if (bestScore == restPath.MatchScore(httpMethod, matchUsingPathParts))
{
return(restPath);
}
}
}
}
var yieldedWildcardMatches = RestPath.GetFirstMatchWildCardHashKeys(matchUsingPathParts);
foreach (var potentialHashMatch in yieldedWildcardMatches)
{
if (!this.RestPathMap.TryGetValue(potentialHashMatch, out firstMatches))
{
continue;
}
var bestScore = -1;
foreach (var restPath in firstMatches)
{
var score = restPath.MatchScore(httpMethod, matchUsingPathParts);
if (score > bestScore)
{
bestScore = score;
}
}
if (bestScore > 0)
{
foreach (var restPath in firstMatches)
{
if (bestScore == restPath.MatchScore(httpMethod, matchUsingPathParts))
{
return(restPath);
}
}
}
}
return(null);
}