public static ApiObject GetQueryObject(ClientGeneratorMethod generatedMethod, Method method, string objectName)
{
var queryObject = new ApiObject { Name = generatedMethod.Name + objectName + "Query" };
queryObject.Properties = ParseParameters(method);
return queryObject;
}
private IEnumerable <Property> BuildResponseProperties(ClientGeneratorMethod method)
{
var properties = new Collection <Property>();
if (method.ReturnType != "string" && method.ReturnType != "HttpContent")
{
properties.Add(new Property
{
Name = "Content",
Description = "Typed Response content",
Type = method.ReturnType
});
}
if (method.ResponseHeaders != null && method.ResponseHeaders.Any())
{
properties.Add(new Property
{
Name = "Headers",
Description = "Typed Response headers (defined in RAML)",
Type = method.ResponseHeaderType
});
}
return(properties);
}
private ClientGeneratorMethod BuildClassMethod(string url, Method method, Resource resource)
{
var parentUrl = UrlGeneratorHelper.GetParentUri(url, resource.RelativeUri);
var generatedMethod = new ClientGeneratorMethod
{
Name = NetNamingMapper.GetMethodName(method.Verb ?? "Get" + resource.RelativeUri),
ReturnType = GetReturnType(GeneratorServiceHelper.GetKeyForResource(method, resource, parentUrl), method, resource, url),
Parameter = GetParameter(GeneratorServiceHelper.GetKeyForResource(method, resource, parentUrl), method, resource, url),
Comment = GetComment(resource, method, url),
Url = url,
Verb = NetNamingMapper.Capitalize(method.Verb),
Parent = null,
UseSecurity =
raml.SecuredBy != null && raml.SecuredBy.Any() ||
resource.Methods.Any(m => m.Verb == method.Verb && m.SecuredBy != null && m.SecuredBy.Any()),
RequestContentTypes = method.Body.Keys.ToArray(),
ResponseContentTypes = method.Responses != null?method.Responses.Where(r => r.Body != null).SelectMany(r => r.Body.Keys).ToArray() : new string[0]
};
// look in traits
// look in resource types
return(generatedMethod);
}
private IEnumerable<Property> BuildResponseProperties(ClientGeneratorMethod method)
{
var properties = new Collection<Property>();
if (method.ReturnType != "string" && method.ReturnType != "HttpContent")
{
properties.Add(new Property
{
Name = "Content",
Description = "Typed Response content",
Type = method.ReturnType
});
}
if (method.ResponseHeaders != null && method.ResponseHeaders.Any())
{
properties.Add(new Property
{
Name = "Headers",
Description = "Typed Response headers (defined in RAML)",
Type = method.ResponseHeaderType
});
}
return properties;
}
public static ApiObject GetHeadersObject(ClientGeneratorMethod generatedMethod, Method method, string objectName)
{
return new ApiObject
{
Name = generatedMethod.Name + objectName + "Header",
Properties = ParseHeaders(method)
};
}
public static ApiObject GetHeadersObject(ClientGeneratorMethod generatedMethod, Response response, string objectName)
{
return new ApiObject
{
Name = generatedMethod.Name + objectName + ParserHelpers.GetStatusCode(response.Code) + "ResponseHeader",
Properties = ParseHeaders(response)
};
}
private void GetHeaders(string objectName, Method method, ClientGeneratorMethod generatedMethod)
{
if (method.Headers != null && method.Headers.Any())
{
var headerObject = HeadersParser.GetHeadersObject(generatedMethod, method, objectName);
generatedMethod.Header = headerObject;
headerObjects.Add(headerObject.Name, headerObject);
}
}
private static string GetOkReturnType(ClientGeneratorMethod generatedMethod)
{
if (!generatedMethod.ReturnTypeObject.IsMultiple)
return generatedMethod.ReturnType;
if (generatedMethod.ReturnTypeObject.Properties.Any(p => p.StatusCode == HttpStatusCode.OK))
return generatedMethod.ReturnTypeObject.Properties.First(p => p.StatusCode == HttpStatusCode.OK).Type;
return generatedMethod.ReturnTypeObject.Properties.First().Type;
}
private IEnumerable<Property> BuildRequestProperties(ClientGeneratorMethod method)
{
var properties = new Collection<Property>();
if (method.Header != null)
{
properties.Add(new Property
{
Name = "Headers",
Description = "Typed Request headers",
Type = method.Header.Name
});
}
if (method.Verb.ToLowerInvariant() != "get" && method.Verb.ToLowerInvariant() != "delete")
{
properties.Add(new Property
{
Name = "Content",
Description = "Request content",
Type = method.Parameter != null && method.Parameter.Type != "string" ? method.Parameter.Type : "HttpContent"
});
properties.Add(new Property
{
Name = "Formatter",
Description = "Request formatter",
Type = "MediaTypeFormatter"
});
}
if (method.Query != null)
{
properties.Add(new Property
{
Name = "Query",
Description = "Request query string properties",
Type = method.Query.Name
});
}
if (method.UriParameters.Any())
{
properties.Add(new Property
{
Name = "UriParameters",
Description = "Request Uri Parameters",
Type = method.UriParametersType
});
}
return properties;
}
private IEnumerable <Property> BuildRequestProperties(ClientGeneratorMethod method)
{
var properties = new Collection <Property>();
if (method.Header != null)
{
properties.Add(new Property
{
Name = "Headers",
Description = "Typed Request headers",
Type = method.Header.Name
});
}
if (method.Verb.ToLowerInvariant() != "get" && method.Verb.ToLowerInvariant() != "delete")
{
properties.Add(new Property
{
Name = "Content",
Description = "Request content",
Type = method.Parameter != null && method.Parameter.Type != "string" ? method.Parameter.Type : "HttpContent"
});
properties.Add(new Property
{
Name = "Formatter",
Description = "Request formatter",
Type = "MediaTypeFormatter"
});
}
if (method.Query != null)
{
properties.Add(new Property
{
Name = "Query",
Description = "Request query string properties",
Type = method.Query.Name
});
}
if (method.UriParameters.Any())
{
properties.Add(new Property
{
Name = "UriParameters",
Description = "Request Uri Parameters",
Type = method.UriParametersType
});
}
return(properties);
}
private void GetQueryParameters(string objectName, Method method, ClientGeneratorMethod generatedMethod)
{
if (method.QueryParameters != null && method.QueryParameters.Any())
{
var queryObject = queryParametersParser.GetQueryObject(generatedMethod, method, objectName);
generatedMethod.Query = queryObject;
if (!queryObjects.ContainsKey(queryObject.Name))
{
queryObjects.Add(queryObject.Name, queryObject);
}
}
}
private static string GetOkReturnType(ClientGeneratorMethod generatedMethod)
{
if (!generatedMethod.ReturnTypeObject.IsMultiple)
{
return(generatedMethod.ReturnType);
}
if (generatedMethod.ReturnTypeObject.Properties.Any(p => p.StatusCode == HttpStatusCode.OK))
{
return(generatedMethod.ReturnTypeObject.Properties.First(p => p.StatusCode == HttpStatusCode.OK).Type);
}
return(generatedMethod.ReturnTypeObject.Properties.First().Type);
}
private static List<Property> BuildProperties(ClientGeneratorMethod generatedMethod)
{
var properties = generatedMethod.ResponseHeaders
.Select(kv => new Property
{
Name = kv.Value.Name,
Description = kv.Value.Description,
Example = kv.Value.Example,
StatusCode = kv.Key,
Type = kv.Value.Name
})
.ToList();
return properties;
}
private static List <Property> BuildProperties(ClientGeneratorMethod generatedMethod)
{
var properties = generatedMethod.ResponseHeaders
.Select(kv => new Property
{
Name = kv.Value.Name,
Description = kv.Value.Description,
Example = kv.Value.Example,
StatusCode = kv.Key,
Type = kv.Value.Name
})
.ToList();
return(properties);
}
private void CreateMultipleType(ClientGeneratorMethod generatedMethod)
{
var properties = BuildProperties(generatedMethod);
var name = NetNamingMapper.GetObjectName("Multiple" + generatedMethod.Name + "Header");
var apiObject = new ApiObject
{
Name = name,
Description = "Multiple Header Types " + string.Join(", ", properties.Select(p => p.Name)),
Properties = properties,
IsMultiple = true
};
responseHeadersObjects.Add(new KeyValuePair <string, ApiObject>(name, apiObject));
generatedMethod.ResponseHeaderType = ClientGeneratorMethod.ModelsNamespacePrefix + name;
}
private ClientGeneratorMethod BuildClassMethod(string url, Method method, Resource resource, IDictionary <string, ApiObject> schemaRequestObjects, IDictionary <string, ApiObject> schemaResponseObjects)
{
var generatedMethod = new ClientGeneratorMethod
{
Name = NetNamingMapper.GetMethodName(method.Verb ?? "Get" + resource.RelativeUri),
ReturnType = GetReturnType(GeneratorServiceHelper.GetKeyForResource(method, resource), method, resource, schemaResponseObjects),
Parameter = GetParameter(GeneratorServiceHelper.GetKeyForResource(method, resource), method, resource, schemaRequestObjects),
Comment = GetComment(resource, method),
Url = url,
Verb = NetNamingMapper.Capitalize(method.Verb),
Parent = null,
UseSecurity =
raml.SecuredBy != null && raml.SecuredBy.Any() ||
resource.Methods.Any(m => m.Verb == method.Verb && m.SecuredBy != null && m.SecuredBy.Any())
};
return(generatedMethod);
}
private void BuildRequest(ClientGeneratorMethod method, ClassObject classObject, ICollection<ApiObject> objects)
{
var requestProperties = BuildRequestProperties(method).ToList();
if (requestProperties.Any())
{
var reqObject = new ApiObject
{
Name = classObject.Name + method.Name + "Request",
Description = "Request object for method " + method.Name + " of class " + classObject.Name,
Properties = requestProperties
};
objects.Add(reqObject);
method.RequestType = ClientGeneratorMethod.ModelsNamespacePrefix + reqObject.Name;
}
else
{
method.RequestType = "ApiRequest";
}
}
private void BuildRequest(ClientGeneratorMethod method, ClassObject classObject, ICollection <ApiObject> objects)
{
var requestProperties = BuildRequestProperties(method).ToList();
if (requestProperties.Any())
{
var reqObject = new ApiObject
{
Name = classObject.Name + method.Name + "Request",
Description = "Request object for method " + method.Name + " of class " + classObject.Name,
Properties = requestProperties
};
objects.Add(reqObject);
method.RequestType = ClientGeneratorMethod.ModelsNamespacePrefix + reqObject.Name;
}
else
{
method.RequestType = "ApiRequest";
}
}
private void BuildResponse(ClientGeneratorMethod method, ClassObject classObject, ICollection <ApiObject> objects)
{
var responseProperties = BuildResponseProperties(method).ToList();
if (responseProperties.Any())
{
var respObject = new ApiObject
{
Name = classObject.Name + method.Name + "Response",
Description = "Response object for method " + method.Name + " of class " + classObject.Name,
Properties = responseProperties,
IsUnionType = method.ReturnTypeObject != null && method.ReturnTypeObject.IsUnionType
};
objects.Add(respObject);
method.ResponseType = ClientGeneratorMethod.ModelsNamespacePrefix + respObject.Name;
}
else
{
method.ResponseType = "ApiResponse";
}
}
public void Generate(Resource resource, string url, ClientGeneratorMethod clientGeneratorMethod,
IDictionary<string, ApiObject> uriParameterObjects, IDictionary<string, Parameter> parentUriParameters)
{
var parameters = GetUriParameters(resource, url, parentUriParameters).ToArray();
clientGeneratorMethod.UriParameters = parameters;
if (!parameters.Any())
return;
var name = NetNamingMapper.GetObjectName(url) + "UriParameters";
clientGeneratorMethod.UriParametersType = name;
if (uriParameterObjects.ContainsKey(name))
return;
var properties = new List<Property>();
if (resource.BaseUriParameters != null)
properties.AddRange(QueryParametersParser.ConvertParametersToProperties(resource.BaseUriParameters));
if (resource.UriParameters != null)
properties.AddRange(QueryParametersParser.ConvertParametersToProperties(resource.UriParameters)
.Where(up => properties.All(p => !String.Equals(up.Name, p.Name, StringComparison.InvariantCultureIgnoreCase))));
var urlParameters = ExtractParametersFromUrl(url).ToArray();
var matchedParameters = MatchParameters(parentUriParameters, urlParameters);
foreach (var urlParameter in matchedParameters)
{
var property = ConvertGeneratorParamToProperty(urlParameter);
if (properties.All(p => !String.Equals(property.Name, p.Name, StringComparison.InvariantCultureIgnoreCase)))
properties.Add(property);
}
var apiObject = new ApiObject
{
Name = name,
Description = "Uri Parameters for resource " + resource.RelativeUri,
Properties = properties
};
uriParameterObjects.Add(name, apiObject);
}
public void Should_Build_Uri_Parameters()
{
var uriParameters = new Dictionary<string, Parameter>
{
{
"code", new Parameter
{
DisplayName = "code",
Type = "integer"
}
}
};
var methods = new List<Method>
{
new Method
{
Verb = "get"
}
};
var resource = new Resource
{
RelativeUri = "/abc{token}{code}",
Methods = methods,
UriParameters = uriParameters
};
var generator = new UriParametersGenerator();
var uriParameterObjects = new Dictionary<string, ApiObject>();
var generatorMethod = new ClientGeneratorMethod { Name = "MethodOne"};
generator.Generate(resource, "/movies/{bucket}/abc{token}{code}", generatorMethod, uriParameterObjects);
Assert.AreEqual(1, uriParameterObjects.Count);
Assert.AreEqual(3, generatorMethod.UriParameters.Count());
Assert.AreEqual(uriParameterObjects.First().Value.Name, generatorMethod.UriParametersType);
}
public void should_parse_query_object()
{
var parameterDynamicRaml = new Dictionary<string, object>
{
{"type", "string"},
{"displayName", "ParameterName"},
{"description", "this is the description"}
};
var parameters = new Dictionary<string, object> {{"one", parameterDynamicRaml}};
var dynamicRaml = new Dictionary<string, object> {{"method", "get"}, {"queryParameters", parameters}};
var generatedMethod = new ClientGeneratorMethod { Name = "GeneratedMethod"};
const string objectName = "ObjName";
var queryObj = QueryParametersParser.GetQueryObject(generatedMethod, new MethodBuilder().Build(dynamicRaml), objectName);
var parsedParameters = queryObj.Properties;
Assert.AreEqual(generatedMethod.Name + objectName + "Query", queryObj.Name);
Assert.AreEqual(1, parsedParameters.Count);
Assert.AreEqual("string", parsedParameters.First().Type);
Assert.AreEqual("One", parsedParameters.First().Name);
}
private void GetResponseHeaders(string objectName, ClientGeneratorMethod generatedMethod, Method method)
{
generatedMethod.ResponseHeaders = new Dictionary <HttpStatusCode, ApiObject>();
foreach (var resp in method.Responses.Where(r => r.Headers != null && r.Headers.Any()))
{
var headerObject = HeadersParser.GetHeadersObject(generatedMethod, resp, objectName);
generatedMethod.ResponseHeaders.Add(ParserHelpers.GetHttpStatusCode(resp.Code), headerObject);
responseHeadersObjects.Add(headerObject.Name, headerObject);
}
if (!generatedMethod.ResponseHeaders.Any())
{
generatedMethod.ResponseHeaderType = defaultHeaderType;
}
else if (generatedMethod.ResponseHeaders.Count == 1)
{
generatedMethod.ResponseHeaderType = ClientGeneratorMethod.ModelsNamespacePrefix + generatedMethod.ResponseHeaders.First().Value.Name;
}
else
{
CreateMultipleType(generatedMethod);
}
}
private ClientGeneratorMethod BuildClassMethod(string url, Method method, Resource resource)
{
var parentUrl = UrlGeneratorHelper.GetParentUri(url, resource.RelativeUri);
var generatedMethod = new ClientGeneratorMethod
{
Name = NetNamingMapper.GetMethodName(method.Verb ?? "Get" + resource.RelativeUri),
ReturnType = GetReturnType(GeneratorServiceHelper.GetKeyForResource(method, resource, parentUrl), method, resource, url),
Parameter = GetParameter(GeneratorServiceHelper.GetKeyForResource(method, resource, parentUrl), method, resource, url),
Comment = GetComment(resource, method),
Url = url,
Verb = NetNamingMapper.Capitalize(method.Verb),
Parent = null,
UseSecurity =
raml.SecuredBy != null && raml.SecuredBy.Any() ||
resource.Methods.Any(m => m.Verb == method.Verb && m.SecuredBy != null && m.SecuredBy.Any()),
RequestContentTypes = method.Body.Keys.ToArray(),
ResponseContentTypes = method.Responses != null ? method.Responses.Where(r => r.Body != null).SelectMany(r => r.Body.Keys).ToArray() : new string[0]
};
return generatedMethod;
}
private ClientGeneratorMethod BuildClassMethod(string url, Method method, Resource resource)
{
var generatedMethod = new ClientGeneratorMethod
{
Name = NetNamingMapper.GetMethodName(method.Verb ?? "Get" + resource.RelativeUri),
ReturnType = GetReturnType(GeneratorServiceHelper.GetKeyForResource(method, resource), method, resource, url),
Parameter = GetParameter(GeneratorServiceHelper.GetKeyForResource(method, resource), method, resource, url),
Comment = GetComment(resource, method),
Url = url,
Verb = NetNamingMapper.Capitalize(method.Verb),
Parent = null,
UseSecurity =
raml.SecuredBy != null && raml.SecuredBy.Any() ||
resource.Methods.Any(m => m.Verb == method.Verb && m.SecuredBy != null && m.SecuredBy.Any())
};
return generatedMethod;
}
private void CreateMultipleType(ClientGeneratorMethod generatedMethod)
{
var properties = BuildProperties(generatedMethod);
var name = NetNamingMapper.GetObjectName("Multiple" + generatedMethod.Name + "Header");
var apiObject = new ApiObject
{
Name = name,
Description = "Multiple Header Types " + string.Join(", ", properties.Select(p => p.Name)),
Properties = properties,
IsMultiple = true
};
responseHeadersObjects.Add(new KeyValuePair<string, ApiObject>(name, apiObject));
generatedMethod.ResponseHeaderType = ClientGeneratorMethod.ModelsNamespacePrefix + name;
}
private void GetResponseHeaders(string objectName, ClientGeneratorMethod generatedMethod, Method method)
{
generatedMethod.ResponseHeaders = new Dictionary<HttpStatusCode, ApiObject>();
foreach (var resp in method.Responses.Where(r => r.Headers != null && r.Headers.Any()))
{
var headerObject = HeadersParser.GetHeadersObject(generatedMethod, resp, objectName);
generatedMethod.ResponseHeaders.Add(ParserHelpers.GetHttpStatusCode(resp.Code), headerObject);
responseHeadersObjects.Add(headerObject.Name, headerObject);
}
if (!generatedMethod.ResponseHeaders.Any())
{
generatedMethod.ResponseHeaderType = defaultHeaderType;
}
else if (generatedMethod.ResponseHeaders.Count == 1)
{
generatedMethod.ResponseHeaderType = ClientGeneratorMethod.ModelsNamespacePrefix + generatedMethod.ResponseHeaders.First().Value.Name;
}
else
{
CreateMultipleType(generatedMethod);
}
}
private void GetHeaders(string objectName, Method method, ClientGeneratorMethod generatedMethod)
{
if (method.Headers != null && method.Headers.Any())
{
var headerObject = HeadersParser.GetHeadersObject(generatedMethod, method, objectName);
generatedMethod.Header = headerObject;
headerObjects.Add(headerObject.Name, headerObject);
}
}
private void GetQueryParameters(string objectName, Method method, ClientGeneratorMethod generatedMethod)
{
if (method.QueryParameters != null && method.QueryParameters.Any())
{
var queryObject = QueryParametersParser.GetQueryObject(generatedMethod, method, objectName);
generatedMethod.Query = queryObject;
if (!queryObjects.ContainsKey(queryObject.Name))
queryObjects.Add(queryObject.Name, queryObject);
}
}
