public static object CreateRequest(IRequest httpReq, RestPath restPath, Dictionary <string, string> requestParams, object requestDto) { var pathInfo = !restPath.IsWildCardPath ? GetSanitizedPathInfo(httpReq.PathInfo, out _) : httpReq.PathInfo; return(restPath.CreateRequest(pathInfo, requestParams, requestDto)); }
public void RegisterRestPaths(HttpListenerHost appHost, Type requestType) { var attrs = appHost.GetRouteAttributes(requestType); foreach (RouteAttribute attr in attrs) { var restPath = new RestPath(appHost.CreateInstance, appHost.GetParseFn, requestType, attr.Path, attr.Verbs, attr.IsHidden, attr.Summary, attr.Description); RegisterRestPath(restPath); } }
public static object CreateRequest(HttpListenerHost host, IRequest httpReq, RestPath restPath, ILogger logger) { var requestType = restPath.RequestType; if (RequireqRequestStream(requestType)) { // Used by IRequiresRequestStream return(CreateRequiresRequestStreamRequest(host, httpReq, requestType)); } var requestParams = GetFlattenedRequestParams(httpReq); return(CreateRequest(host, httpReq, restPath, requestParams)); }
public StringMapTypeDeserializer(Func <Type, object> createInstanceFn, Func <Type, Func <string, object> > getParseFn, Type type) { _CreateInstanceFn = createInstanceFn; _GetParseFn = getParseFn; this.type = type; foreach (var propertyInfo in RestPath.GetSerializableProperties(type)) { var propertySetFn = TypeAccessor.GetSetPropertyMethod(type, propertyInfo); var propertyType = propertyInfo.PropertyType; var propertyParseStringFn = GetParseFn(propertyType); var propertySerializer = new PropertySerializerEntry(propertySetFn, propertyParseStringFn, propertyType); propertySetterMap[propertyInfo.Name] = propertySerializer; } }
private Dictionary <string, SwaggerMethod> GetPathInfo(RestPath info) { var result = new Dictionary <string, SwaggerMethod>(); foreach (var verb in info.Verbs) { var responses = new Dictionary <string, SwaggerResponse> { }; responses["200"] = new SwaggerResponse { description = "OK" }; var security = new List <Dictionary <string, string[]> >(); var apiKeySecurity = new Dictionary <string, string[]>(); apiKeySecurity["api_key"] = new string[] { }; security.Add(apiKeySecurity); result[verb.ToLower()] = new SwaggerMethod { summary = info.Summary, description = info.Description, produces = new[] { "application/json" }, consumes = new[] { "application/json" }, operationId = info.RequestType.Name, tags = new string[] { }, parameters = new SwaggerParam[] { }, responses = responses, security = security.ToArray() }; } return(result); }
public void RegisterRestPaths(HttpListenerHost appHost, Type requestType) { var attrs = appHost.GetRouteAttributes(requestType); foreach (RouteAttribute attr in attrs) { var restPath = new RestPath(appHost.CreateInstance, appHost.GetParseFn, requestType, attr.Path, attr.Verbs, attr.Summary, attr.Notes); if (!restPath.IsValid) { throw new NotSupportedException(string.Format( "RestPath '{0}' on Type '{1}' is not Valid", attr.Path, requestType.GetMethodName())); } RegisterRestPath(restPath); } }
public void RegisterRestPath(RestPath restPath) { if (!restPath.Path.StartsWith("/")) { throw new ArgumentException(string.Format("Route '{0}' on '{1}' must start with a '/'", restPath.Path, restPath.RequestType.GetMethodName())); } if (restPath.Path.IndexOfAny(InvalidRouteChars) != -1) { throw new ArgumentException(string.Format("Route '{0}' on '{1}' contains invalid chars. ", restPath.Path, restPath.RequestType.GetMethodName())); } if (!RestPathMap.TryGetValue(restPath.FirstMatchHashKey, out List <RestPath> pathsAtFirstMatch)) { pathsAtFirstMatch = new List <RestPath>(); RestPathMap[restPath.FirstMatchHashKey] = pathsAtFirstMatch; } pathsAtFirstMatch.Add(restPath); }
public static object CreateRequest(HttpListenerHost host, IRequest httpReq, RestPath restPath, ILogger logger) { var requestType = restPath.RequestType; if (RequireqRequestStream(requestType)) { // Used by IRequiresRequestStream var request = ServiceHandler.CreateRequest(httpReq, restPath, GetRequestParams(httpReq), host.CreateInstance(requestType)); var rawReq = (IRequiresRequestStream)request; rawReq.RequestStream = httpReq.InputStream; return(rawReq); } var requestParams = GetFlattenedRequestParams(httpReq); return(CreateRequest(host, httpReq, restPath, requestParams)); }
private Dictionary <string, SwaggerMethod> GetPathInfo(RestPath info) { var result = new Dictionary <string, SwaggerMethod>(); foreach (var verb in info.Verbs) { var responses = new Dictionary <string, SwaggerResponse> { { "200", new SwaggerResponse { description = "OK" } } }; var apiKeySecurity = new Dictionary <string, string[]> { { "api_key", Array.Empty <string>() } }; result[verb.ToLowerInvariant()] = new SwaggerMethod { summary = info.Summary, description = info.Description, produces = new[] { "application/json" }, consumes = new[] { "application/json" }, operationId = info.RequestType.Name, tags = Array.Empty <string>(), parameters = Array.Empty <SwaggerParam>(), responses = responses, security = new [] { apiKeySecurity } }; } return(result); }
private static void SetRoute(IRequest req, RestPath route) { req.Items["__route"] = route; }
public static async Task <object> CreateRequest(HttpListenerHost host, IRequest httpReq, RestPath restPath, ILogger logger) { var requestType = restPath.RequestType; if (RequireqRequestStream(requestType)) { // Used by IRequiresRequestStream var requestParams = await GetRequestParams(httpReq).ConfigureAwait(false); var request = ServiceHandler.CreateRequest(httpReq, restPath, requestParams, host.CreateInstance(requestType)); var rawReq = (IRequiresRequestStream)request; rawReq.RequestStream = httpReq.InputStream; return(rawReq); } else { var requestParams = await GetFlattenedRequestParams(httpReq).ConfigureAwait(false); var requestDto = await CreateContentTypeRequest(host, httpReq, restPath.RequestType, httpReq.ContentType).ConfigureAwait(false); return(CreateRequest(httpReq, restPath, requestParams, requestDto)); } }
public RestPath GetRestPathForRequest(string httpMethod, string pathInfo, ILogger logger) { 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, logger); if (score > bestScore) { bestScore = score; } } if (bestScore > 0) { foreach (var restPath in firstMatches) { if (bestScore == restPath.MatchScore(httpMethod, matchUsingPathParts, logger)) { 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, logger); if (score > bestScore) { bestScore = score; } } if (bestScore > 0) { foreach (var restPath in firstMatches) { if (bestScore == restPath.MatchScore(httpMethod, matchUsingPathParts, logger)) { return(restPath); } } } } return(null); }
public static object CreateRequest(HttpListenerHost host, IRequest httpReq, RestPath restPath, Dictionary <string, string> requestParams) { var requestDto = CreateContentTypeRequest(host, httpReq, restPath.RequestType, httpReq.ContentType); return(CreateRequest(httpReq, restPath, requestParams, requestDto)); }
internal ServiceHandler(RestPath restPath, string responseContentType) { _restPath = restPath; _responseContentType = responseContentType; }