public ApiParameter CreateParameter(ApiParameterDescription parameterDescription, string relativePath)
        {
            var trueParamType = parameterDescription.ParameterDescriptor.ParameterType;

            var paramType = GetParamType(parameterDescription, relativePath);
            var isRequired = !parameterDescription.ParameterDescriptor.IsOptional;
            var dataType =  GetFriendlyTypeName(trueParamType);
            var allowMuliple = GetAllowMuliple(trueParamType);

            if (parameterDescription.ParameterDescriptor.ParameterType.IsEnum)
            {
                var possibleValues = new AllowableValues(trueParamType);
                return new ApiEnumParameter()
                {
                    name = parameterDescription.Name,
                    dataType = dataType,
                    paramType = paramType.ToString(),
                    description = parameterDescription.Documentation,
                    allowMultiple = allowMuliple,
                    required = isRequired,
                    allowableValues = possibleValues
                };        
            }

            return  new ApiParameter()
                          {
                              name = parameterDescription.Name,
                              dataType = dataType,
                              paramType = paramType.ToString(),
                              description = parameterDescription.Documentation,
                              allowMultiple = allowMuliple,
                              required = isRequired
                          };
        }
 public ApiParameter(System.Web.Http.Description.ApiParameterDescription param, XmlDocumentationProvider xmlDocProvider)
     : this()
 {
     this.Name          = param.Name;
     this.Type          = GetPropertyType(param.ParameterDescriptor.ParameterType);
     this.Documentation = param.Documentation;
 }
 private static ParamType GetParamType(ApiParameterDescription parameterDescription, string relativePath)
 {
     var paramType = ParamType.body;
     if (parameterDescription.Source == ApiParameterSource.FromUri)
     {
         paramType = relativePath.IndexOf("{" + parameterDescription.Name + "}") > -1 ? ParamType.path :  ParamType.query;
     }
     return paramType;
 }
Beispiel #4
0
 private System.Web.Http.Description.ApiParameterDescription CreateParameterDescriptionFromDescriptor(HttpParameterDescriptor parameter)
 {
     System.Web.Http.Description.ApiParameterDescription parameterDescription = new System.Web.Http.Description.ApiParameterDescription();
     parameterDescription.ParameterDescriptor = parameter;
     parameterDescription.Name          = parameter.Prefix ?? parameter.ParameterName;
     parameterDescription.Documentation = GetApiParameterDocumentation(parameter);
     parameterDescription.Source        = ApiParameterSource.Unknown;
     return(parameterDescription);
 }
Beispiel #5
0
        private void PopulateActionDescriptions(HttpActionDescriptor actionDescriptor, IHttpRoute route, string localPath, Collection <System.Web.Http.Description.ApiDescription> apiDescriptions)
        {
            string apiDocumentation = GetApiDocumentation(actionDescriptor);

            // parameters
            IList <System.Web.Http.Description.ApiParameterDescription> parameterDescriptions = CreateParameterDescriptions(actionDescriptor);

            // expand all parameter variables
            string finalPath;

            if (!TryExpandUriParameters(route, actionDescriptor, parameterDescriptions, out finalPath))
            {
                // the action cannot be reached due to parameter mismatch, e.g. routeTemplate = "/users/{name}" and GetUsers(id)
                return;
            }

            // request formatters
            System.Web.Http.Description.ApiParameterDescription bodyParameter = parameterDescriptions.FirstOrDefault(description => description.Source == ApiParameterSource.FromBody);
            IEnumerable <MediaTypeFormatter> supportedRequestBodyFormatters   = bodyParameter != null?
                                                                                actionDescriptor.Configuration.Formatters.Where(f => f.CanReadType(bodyParameter.ParameterDescriptor.ParameterType)) :
                                                                                    Enumerable.Empty <MediaTypeFormatter>();

            // response formatters
            Type returnType = actionDescriptor.ReturnType;
            IEnumerable <MediaTypeFormatter> supportedResponseFormatters = returnType != null?
                                                                           actionDescriptor.Configuration.Formatters.Where(f => f.CanWriteType(returnType)) :
                                                                               Enumerable.Empty <MediaTypeFormatter>();

            // get HttpMethods supported by an action. Usually there is one HttpMethod per action but we allow multiple of them per action as well.
            IList <HttpMethod> supportedMethods = this.GetHttpMethodsSupportedByAction(route, actionDescriptor);

            foreach (HttpMethod method in supportedMethods)
            {
                var description = new System.Web.Http.Description.ApiDescription()
                {
                    Documentation    = apiDocumentation,
                    HttpMethod       = method,
                    RelativePath     = finalPath,
                    ActionDescriptor = actionDescriptor,
                    Route            = route
                };
                foreach (var mtf in supportedRequestBodyFormatters)
                {
                    description.SupportedRequestBodyFormatters.Add(mtf);
                }
                foreach (var mtf in supportedResponseFormatters)
                {
                    description.SupportedResponseFormatters.Add(mtf);
                }
                foreach (var par in parameterDescriptions)
                {
                    description.ParameterDescriptions.Add(par);
                }

                apiDescriptions.Add(description);
            }
        }
Beispiel #6
0
        public static ApiParameterDescription CreateParameter(string name, Type type, bool isOptional, ApiParameterSource source)
        {
            var p = MockRepository.GenerateStub<HttpParameterDescriptor>();
            p.Stub(x => x.ParameterName).Return(name);
            p.Stub(x => x.ParameterType).Return(type);
            p.Stub(x => x.IsOptional).Return(isOptional);

            var apiParam = new ApiParameterDescription() { ParameterDescriptor = p, Name = name, Source = source, Documentation = "yada" };
            return apiParam;
        }
Beispiel #7
0
        private System.Web.Http.Description.ApiParameterDescription CreateParameterDescriptionFromBinding(HttpParameterBinding parameterBinding)
        {
            System.Web.Http.Description.ApiParameterDescription parameterDescription = CreateParameterDescriptionFromDescriptor(parameterBinding.Descriptor);
            if (parameterBinding.WillReadBody)
            {
                parameterDescription.Source = ApiParameterSource.FromBody;
            }
            else if (parameterBinding.WillReadUri())
            {
                parameterDescription.Source = ApiParameterSource.FromUri;
            }

            return(parameterDescription);
        }
        public void GetBindableProperties_WorksOnlyFor_PublicInstanceProperties_WithPublicGettersAndSetters()
        {
            // Arrange
            ApiParameterDescription parameter = new ApiParameterDescription();
            Mock<HttpParameterDescriptor> parameterDescriptorMock = new Mock<HttpParameterDescriptor>();
            parameterDescriptorMock.SetupGet(p => p.ParameterType).Returns(typeof(ClassWithAllKindsOfProperties));
            parameter.ParameterDescriptor = parameterDescriptorMock.Object;

            // Act
            IEnumerable<PropertyInfo> bindableProperties = parameter.GetBindableProperties();

            // Assert
            Assert.Equal(1, bindableProperties.Count());
            Assert.Equal("ValidProperty", bindableProperties.Single().Name);
        }
Beispiel #9
0
 /// <summary>
 /// Creates an operation parameter
 /// </summary>
 /// <param name="param">Description of a parameter on an operation via the ApiExplorer</param>
 /// <returns>An operation parameter</returns>
 public Parameter CreateParameter(ApiParameterDescription param)
 {
     var returnType = param.ParameterDescriptor.ParameterType.GetSwaggerType();
     return new Parameter()
     {
         ParamTypeEnum = param.GetParamType(),
         Name = param.Name,
         Description = param.Documentation,
         Type = returnType.Type,
         Format = returnType.Format,
         Enum = returnType.Enum,
         Required = !param.ParameterDescriptor.IsOptional,
         Items = param.ParameterDescriptor.ParameterType.IsIEnumerable() ? new Items{ Type = "string" } : null 
     };
 }
        private Parameter CreateParameter(ApiParameterDescription apiParamDesc, string apiPath)
        {
            var paramType = "";
            switch (apiParamDesc.Source)
            {
                case ApiParameterSource.FromBody:
                    paramType = "body";
                    break;

                case ApiParameterSource.FromUri:
                    paramType = apiPath.Contains(String.Format("{{{0}}}", apiParamDesc.Name)) ? "path" : "query";
                    break;
            }

            if (apiParamDesc.ParameterDescriptor == null)
            {
                return new Parameter { ParamType = paramType, Name = apiParamDesc.Name, Required = true, Type = "string" };
            }

            var parameter = new Parameter
            {
                ParamType = paramType,
                Name = apiParamDesc.Name,
                Description = apiParamDesc.Documentation,
                Required = !apiParamDesc.ParameterDescriptor.IsOptional
            };

            var dataType = _dataTypeRegistry.GetOrRegister(apiParamDesc.ParameterDescriptor.ParameterType);
            if (dataType.Type == "object")
            {
                parameter.Type = dataType.Id;
            }
            else
            {
                parameter.Type = dataType.Type;
                parameter.Format = dataType.Format;
                parameter.Items = dataType.Items;
                parameter.Enum = dataType.Enum;
            }

            return parameter;
        }
Beispiel #11
0
        public virtual Type ResolveType(System.Web.Http.Description.ApiDescription api, string controllerName, string actionName, IEnumerable <string> parameterNames, SampleDirection sampleDirection, out Collection <MediaTypeFormatter> formatters)
        {
            Throw.IfEnumNotDefined <SampleDirection>(sampleDirection, "sampleDirection");
            Throw.IfArgumentNull(api, "api");
            Type type;

            if (ActualHttpMessageTypes.TryGetValue(new HelpPageSampleKey(sampleDirection, controllerName, actionName, parameterNames), out type) ||
                ActualHttpMessageTypes.TryGetValue(new HelpPageSampleKey(sampleDirection, controllerName, actionName, new string[] {  }), out type))
            {
                // Re-compute the supported formatters based on type
                Collection <MediaTypeFormatter> newFormatters = new Collection <MediaTypeFormatter>();
                foreach (var formatter in api.ActionDescriptor.Configuration.Formatters)
                {
                    if (IsFormatSupported(sampleDirection, formatter, type))
                    {
                        newFormatters.Add(formatter);
                    }
                }
                formatters = newFormatters;
            }
            else
            {
                switch (sampleDirection)
                {
                case SampleDirection.Request:
                    System.Web.Http.Description.ApiParameterDescription requestBodyParameter = api.ParameterDescriptions.FirstOrDefault(p => p.Source == ApiParameterSource.FromBody);
                    type       = requestBodyParameter == null ? null : requestBodyParameter.ParameterDescriptor.ParameterType;
                    formatters = api.SupportedRequestBodyFormatters;
                    break;

                case SampleDirection.Response:
                default:
                    type       = api.ActionDescriptor.ReturnType;
                    formatters = api.SupportedResponseFormatters;
                    break;
                }
            }

            return(type);
        }
        private Parameter CreateParameter(ApiParameterDescription apiParamDesc, string apiPath, Dictionary<string, DataType> complexModels)
        {
            var paramType = "";
            switch (apiParamDesc.Source)
            {
                case ApiParameterSource.FromBody:
                    paramType = "body";
                    break;
                case ApiParameterSource.FromUri:
                    paramType = apiPath.Contains(String.Format("{{{0}}}", apiParamDesc.Name)) ? "path" : "query";
                    break;
            }

            var parameter = new Parameter
            {
                ParamType = paramType,
                Name = apiParamDesc.Name,
                Description = apiParamDesc.Documentation,
                Required = !apiParamDesc.ParameterDescriptor.IsOptional
            };

            IDictionary<string, DataType> complexModelsForParameter;
            var dataType = _dataTypeGenerator.TypeToDataType(apiParamDesc.ParameterDescriptor.ParameterType, out complexModelsForParameter);

            complexModels.Merge(complexModelsForParameter);

            if (dataType.Type == "object")
            {
                parameter.Type = dataType.Id;
            }
            else
            {
                parameter.Type = dataType.Type;
                parameter.Format = dataType.Format;
                parameter.Items = dataType.Items;
                parameter.Enum = dataType.Enum;
            }

            return parameter;
        }
        private static string BuildArguments(ApiParameterDescription[] parameters)
        {
            if(parameters == null || parameters.Length == 0)
            {
                return string.Empty;
            }

            StringBuilder sb = new StringBuilder();

            int i = 0;
            foreach(var p in parameters)
            {
                sb.Append(p.Name);
                if(i!= parameters.Length-1)
                {
                    sb.Append(",");
                }
                i += 1;
            }

            return sb.ToString();
        }
        private ParameterSpec CreateParameterSpec(ApiParameterDescription apiParamDesc, string apiPath, ModelSpecRegistrar modelSpecRegistrar)
        {
            var paramType = "";
            switch (apiParamDesc.Source)
            {
                case ApiParameterSource.FromBody:
                    paramType = "body";
                    break;
                case ApiParameterSource.FromUri:
                    paramType = apiPath.Contains(apiParamDesc.Name) ? "path" : "query";
                    break;
            }

            var paramSpec = new ParameterSpec
            {
                ParamType = paramType,
                Name = apiParamDesc.Name,
                Description = apiParamDesc.Documentation,
                Required = !apiParamDesc.ParameterDescriptor.IsOptional
            };

            var modelSpec = _modelSpecGenerator.From(apiParamDesc.ParameterDescriptor.ParameterType, modelSpecRegistrar);

            if (modelSpec.Type == "object")
            {
                paramSpec.Type = modelSpec.Id;
            }
            else
            {
                paramSpec.Type = modelSpec.Type;
                paramSpec.Format = modelSpec.Format;
                paramSpec.Items = modelSpec.Items;
                paramSpec.Enum = modelSpec.Enum;
            }

            return paramSpec;
        }
        public static ParameterDescription AddParameterDescription(
            this Collection<ParameterDescription> uriParameters,
            ApiParameterDescription apiParameter, ModelDescription typeDescription)
        {
            var parameterDescription = new ParameterDescription
            {
                Name = apiParameter.Name,
                Documentation = apiParameter.Documentation,
                TypeDescription = typeDescription,
            };

            uriParameters.Add(parameterDescription);
            return parameterDescription;
        }
 public ApiEndpointParameterModel(ApiParameterDescription desc)
 {
     this.Documentation = desc.Documentation;
     this.Name = desc.Name;
     this.Optional = desc.ParameterDescriptor.IsOptional;
 }
        private Parameter CreateParameter(ApiParameterDescription paramDesc, bool inPath, SchemaRegistry schemaRegistry)
        {
            var @in = (inPath)
                ? "path"
                : (paramDesc.Source == ApiParameterSource.FromUri) ? "query" : "body";

            var parameter = new Parameter
            {
                name = paramDesc.Name,
                @in = @in
            };

            if (paramDesc.ParameterDescriptor == null)
            {
                parameter.type = "string";
                parameter.required = true;
                return parameter;
            }

            parameter.required = inPath || !paramDesc.ParameterDescriptor.IsOptional;
            parameter.@default = paramDesc.ParameterDescriptor.DefaultValue;

            var schema = schemaRegistry.GetOrRegister(paramDesc.ParameterDescriptor.ParameterType);

            var reflectedDescriptor = (ReflectedHttpParameterDescriptor)paramDesc.ParameterDescriptor;
            foreach (var attribute in reflectedDescriptor.ParameterInfo.GetCustomAttributes(true))
            {
                SchemaExtensions.SetSchemaDetails(schema, attribute);
            }

            //if (paramDesc.ParameterDescriptor.ActionDescriptor != null)
            //{
            //    var actionIgnore = paramDesc.ParameterDescriptor.ActionDescriptor.GetCustomAttributes<SwaggerIgnore>();

            //    if (actionIgnore != null)
            //    {
            //        parameter.ignore = true;
            //    }
            //}

            if (parameter.@in == "body")
                parameter.schema = schema;
            else
                parameter.PopulateFrom(schema);

            return parameter;
        }
Beispiel #18
0
        /// <summary>
        /// Creates an operation parameter
        /// </summary>
        /// <param name="api">Description of the api via the ApiExplorer</param>
        /// <param name="param">Description of a parameter on an operation via the ApiExplorer</param>
        /// <param name="docProvider">Access to the XML docs written in code</param>
        /// <returns>An operation parameter</returns>
        public static ResourceApiOperationParameter CreateResourceApiOperationParameter(ApiDescription api, ApiParameterDescription param, XmlCommentDocumentationProvider docProvider)
        {
            string paramType = (param.Source.ToString().Equals(FROMURI)) ? QUERY : BODY;
            ResourceApiOperationParameter parameter = new ResourceApiOperationParameter()
            {
                paramType = (paramType == "query" && api.RelativePath.IndexOf("{" + param.Name + "}") > -1) ? PATH : paramType,
                name = param.Name,
                description = param.Documentation,
                dataType = param.ParameterDescriptor.ParameterType.Name,
                required = docProvider.GetRequired(param.ParameterDescriptor)
            };

            return parameter;
        }
        private static ParameterDescription AddParameterDescription(HelpPageApiModel apiModel,
            ApiParameterDescription apiParameter, ModelDescription typeDescription)
        {
            ParameterDescription parameterDescription = new ParameterDescription
            {
                Name = apiParameter.Name,
                Documentation = apiParameter.Documentation,
                TypeDescription = typeDescription,
            };

            apiModel.UriParameters.Add(parameterDescription);
            return parameterDescription;
        }
        /// <summary>
        /// Creates an operation parameter
        /// </summary>
        /// <param name="api">Description of the api via the ApiExplorer</param>
        /// <param name="param">Description of a parameter on an operation via the ApiExplorer</param>
        /// <param name="docProvider">Access to the XML docs written in code</param>
        /// <returns>An operation parameter</returns>
        public static ResourceApiOperationParameter CreateResourceApiOperationParameter(ApiDescription api, ApiParameterDescription param, XmlCommentDocumentationProvider docProvider)
        {
            string paramType = (param.Source.ToString().Equals(FROMURI)) ? QUERY : BODY;

            var parameter = new ResourceApiOperationParameter()
            {
                paramType = (paramType == "query" && api.RelativePath.IndexOf("{" + param.Name + "}") > -1) ? PATH : paramType,
                name = param.Name,
                description = param.Documentation,
                dataType = TypeParser.Parse(param.ParameterDescriptor.ParameterType),
                required = docProvider.GetRequired(param.ParameterDescriptor)
            };

            parameter.allowMultiple = parameter.dataType.StartsWith("List[");
            parameter.allowableValues = CreateAllowableValues(param.ParameterDescriptor.ParameterType);

            CustomAttributeHelper.PrepareByOptionAttribute(parameter, param.ParameterDescriptor);

            return parameter;
        }
 private static Parameter GetParameterFromProperty(ApiParameterDescription apiParam, PropertyInfo property)
 {
     var parameter = new Parameter
     {
         Default = IsNullable(property.PropertyType) ? "null" : null,
         Required = !IsNullable(property.PropertyType),
         Type = SchemaTypeMapper.Map(property.PropertyType)
     };
     return parameter;
 }
 private ApiParameterDescription CreateParameterDescriptionFromDescriptor(HttpParameterDescriptor parameter)
 {
     ApiParameterDescription parameterDescription = new ApiParameterDescription();
     parameterDescription.ParameterDescriptor = parameter;
     parameterDescription.Name = parameter.Prefix ?? parameter.ParameterName;
     parameterDescription.Documentation = GetApiParameterDocumentation(parameter);
     parameterDescription.Source = ApiParameterSource.Unknown;
     return parameterDescription;
 }
        private static Func<MediaTypeFormatter, bool> CanReadODataType(ODataActionDescriptor oDataActionDescriptor, ApiParameterDescription bodyParameter)
        {
            return mediaTypeFormatter =>
            {
                var oDataMediaTypeFormatter = mediaTypeFormatter as ODataMediaTypeFormatter;

                if (oDataMediaTypeFormatter != null)
                {
                    oDataMediaTypeFormatter.SetInstanceProperty("Request", oDataActionDescriptor.Request);
                    return mediaTypeFormatter.CanReadType(bodyParameter.ParameterDescriptor.ParameterType);
                }
                return false;
            };
        }
 private static Parameter GetPrimitiveParameter(ApiParameterDescription apiParam)
 {
     var parameter = new Parameter
     {
         Default =
             apiParam.ParameterDescriptor.DefaultValue == null
                 ? (apiParam.ParameterDescriptor.IsOptional ? "null" : null)
                 : apiParam.ParameterDescriptor.DefaultValue.ToString(),
         Required = !apiParam.ParameterDescriptor.IsOptional,
         Type = SchemaTypeMapper.Map(apiParam.ParameterDescriptor.ParameterType),
         Description = apiParam.Documentation
     };
     return parameter;
 }
        private void GetParametersFromComplexType(ApiParameterDescription apiParam, IDictionary<string, Parameter> queryParams)
        {
            var properties = apiParam.ParameterDescriptor.ParameterType
                .GetProperties().Where(p => p.CanWrite);
            foreach (var property in properties)
            {
                if(!IsPrimitiveType(property.PropertyType))
                    continue;

                var parameter = GetParameterFromProperty(apiParam, property);

                if (!queryParams.ContainsKey(property.Name))
                    queryParams.Add(property.Name, parameter);
            }
        }
 public static IList<ResourceModelNode> CreateResourceModel(ApiParameterDescription param, XmlCommentDocumentationProvider docProvider)
 {
     return CreateResourceModel(param, param.ParameterDescriptor.ParameterType, docProvider);
 }
 private static ApiParameter MakeParameter(ApiParameterDescription apd)
 {
     Type ptype = apd.ParameterDescriptor.ParameterType;
     ApiParameter p = MakeParameter(ptype);
     p.Name = apd.Name;
     return p;
 }
        private ParameterSpec GenerateParameterSpec(ApiParameterDescription parameterDescription, string apiPath, ModelSpecMap modelSpecMap)
        {
            var paramType = "";
            switch (parameterDescription.Source)
            {
                case ApiParameterSource.FromBody:
                    paramType = "body";
                    break;
                case ApiParameterSource.FromUri:
                    paramType = apiPath.Contains(parameterDescription.Name) ? "path" : "query";
                    break;
            }

            var paramSpec = new ParameterSpec
            {
                ParamType = paramType,
                Name = parameterDescription.Name,
                Description = parameterDescription.Documentation,
                Required = !parameterDescription.ParameterDescriptor.IsOptional
            };

            var modelSpec = modelSpecMap.FindOrCreateFor(parameterDescription.ParameterDescriptor.ParameterType);
            if (modelSpec.Type == "object")
            {
                paramSpec.Type = modelSpec.Id;
            }
            else
            {
                paramSpec.Type = modelSpec.Type;
                paramSpec.Format = modelSpec.Format;
                paramSpec.Items = modelSpec.Items;
                paramSpec.Enum = modelSpec.Enum;
            }

            return paramSpec;
        }
        private static Func<MediaTypeFormatter, bool> CanReadODataType(ODataActionDescriptor oDataActionDescriptor, ApiParameterDescription bodyParameter)
        {
            return mediaTypeFormatter =>
            {
                var oDataMediaTypeFormatter = mediaTypeFormatter as ODataMediaTypeFormatter;

                if (oDataMediaTypeFormatter != null)
                {
                    var mediaType = oDataMediaTypeFormatter.SupportedMediaTypes.FirstOrDefault();
                    var instanceFormatter = oDataMediaTypeFormatter.GetPerRequestFormatterInstance(bodyParameter.ParameterDescriptor.ParameterType,
                        oDataActionDescriptor.Request, mediaType);
                    return instanceFormatter.CanReadType(bodyParameter.ParameterDescriptor.ParameterType);
                }
                return false;
            };
        }
        private static Parameter CreateParameter(ApiParameterDescription paramDesc, bool inPath, SchemaRegistry schemaRegistry, IEdmModel edmModel)
        {
            Contract.Requires(paramDesc != null);
            Contract.Requires(schemaRegistry != null);
            Contract.Assume(paramDesc.ParameterDescriptor != null);

            var @in = inPath
                ? "path"
                : paramDesc.Source == ApiParameterSource.FromUri ? "query" : "body";

            var parameter = new Parameter
            {
                name = paramDesc.Name,
                @in = @in,
                required = inPath || !paramDesc.ParameterDescriptor.IsOptional,
                @default = paramDesc.ParameterDescriptor.DefaultValue
            };

            var schema = schemaRegistry.GetOrRegisterParameterType(edmModel, paramDesc.ParameterDescriptor);
            if (parameter.@in == "body")
                parameter.schema = schema;
            else
                parameter.PopulateFrom(schema);

            return parameter;
        }
Beispiel #31
0
        private Parameter CreateParameter(string location, ApiParameterDescription paramDesc, SchemaRegistry schemaRegistry)
        {
            var parameter = new Parameter
            {
                @in = location,
                name = paramDesc.Name
            };

            if (paramDesc.ParameterDescriptor == null)
            {
                parameter.type = "string";
                parameter.required = true;
                return parameter;
            }

            parameter.required = location == "path" || !paramDesc.ParameterDescriptor.IsOptional;
            parameter.@default = paramDesc.ParameterDescriptor.DefaultValue;

            var schema = schemaRegistry.GetOrRegister(paramDesc.ParameterDescriptor.ParameterType);
            if (parameter.@in == "body")
                parameter.schema = schema;
            else
                parameter.PopulateFrom(schema);

            return parameter;
        }
        private Parameter CreateParameter(ApiParameterDescription paramDesc, bool inPath, SchemaRegistry schemaRegistry)
        {
            var @in = (inPath)
                ? "path"
                : (paramDesc.Source == ApiParameterSource.FromUri) ? "query" : "body";

            var parameter = new Parameter
            {
                name = paramDesc.Name,
                @in = @in
            };

            if (paramDesc.ParameterDescriptor == null)
            {
                parameter.type = "string";
                parameter.required = true;
                return parameter; 
            }

            parameter.required = !paramDesc.ParameterDescriptor.IsOptional;

            var schema = schemaRegistry.GetOrRegister(paramDesc.ParameterDescriptor.ParameterType);
            if (parameter.@in == "body")
                parameter.schema = schema;
            else
                parameter.PopulateFrom(schema);

            return parameter;
        }
Beispiel #33
0
 private string GetParameterLocation(ApiDescription apiDesc, ApiParameterDescription paramDesc)
 {
     if (apiDesc.RelativePathSansQueryString().Contains("{" + paramDesc.Name + "}"))
         return "path";
     else if (paramDesc.Source == ApiParameterSource.FromBody && apiDesc.HttpMethod != HttpMethod.Get)
         return "body";
     else
         return "query";
 }
        private static bool TryGetResourceParameter(ApiDescription apiDescription, HttpConfiguration config, out ApiParameterDescription parameterDescription, out Type resourceType)
        {
            parameterDescription = apiDescription.ParameterDescriptions.FirstOrDefault(
                p => p.Source == ApiParameterSource.FromBody ||
                    (p.ParameterDescriptor != null && p.ParameterDescriptor.ParameterType == typeof(HttpRequestMessage)));

            if (parameterDescription == null)
            {
                resourceType = null;
                return false;
            }

            resourceType = parameterDescription.ParameterDescriptor.ParameterType;

            if (resourceType == typeof(HttpRequestMessage))
            {
                HelpPageSampleGenerator sampleGenerator = config.GetHelpPageSampleGenerator();
                resourceType = sampleGenerator.ResolveHttpRequestMessageType(apiDescription);
            }

            if (resourceType == null)
            {
                parameterDescription = null;
                return false;
            }

            return true;
        }
        private static IList<ResourceModelNode> CreateResourceModel(ApiParameterDescription param, Type modelType, XmlCommentDocumentationProvider docProvider)
        {
            lock (s_lock)
            {
                var result = new List<ResourceModelNode>();
                ResourceModelNode rModel = null;

                if ((!modelType.IsEnum && !modelType.Equals(typeof(string))))
                {
                    if (modelType.IsGenericType)
                    {
                        modelType = modelType.GetGenericArguments().First();
                        return CreateResourceModel(param, modelType, docProvider);
                    }

                    if (s_cache.ContainsKey(modelType))
                    {
                        result.AddRange(s_cache[modelType]);
                        return result;
                    }


                    rModel = new ResourceModelNode()
                    {
                        Id = TypeParser.Parse(modelType.Name)
                    };

                    s_cache.Add(modelType, result);

                    foreach (var typeProperty in modelType.GetProperties(BindingFlags.Public | BindingFlags.Instance))
                    {
                        var property = new ResourceModelPropertyNode();
                        property.Id = TypeParser.Parse(typeProperty.Name);
                        property.Type = TypeParser.Parse(typeProperty.PropertyType);

                        if (typeProperty.PropertyType.IsValueType || Nullable.GetUnderlyingType(typeProperty.PropertyType) == null)
                        {
                            rModel.Required.Add(property.Id);
                        }

                        if (property.Type.StartsWith("List["))
                        {
                            property.Type = "array";

                            var itemType = typeProperty.PropertyType.GetGenericArguments().FirstOrDefault();

                            if (itemType == null)
                            {
                                itemType = typeProperty.PropertyType;
                            }

                            property.DefineContainerType(itemType);
                        }

                        result.AddRange(CreateResourceModel(typeProperty.PropertyType, docProvider));

                        if (docProvider != null)
                        {
                            property.Description = docProvider.GetDocumentation(typeProperty);

                            if (typeProperty.PropertyType.IsEnum)
                            {
                                property.AllowableValues = CreateAllowableValues(typeProperty.PropertyType);

                            }
                            else if ((typeProperty.PropertyType.IsClass || typeProperty.PropertyType.IsValueType) && typeof(string) != typeProperty.PropertyType)
                            {
                                result.AddRange(CreateResourceModel(typeProperty.PropertyType, docProvider));

                            }
                        }

                        rModel.Properties.Add(property);
                    }

                    if (rModel.Properties.Count > 0)
                    {
                        result.Add(rModel);
                    }
                }

                return result;
            }
        }