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; }
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); }
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); } }
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; }
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); }
/// <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; }
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; }
/// <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; }
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; }
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; } }