private string GetScalarType(RamlType ramlType)
{
var type = NetTypeMapper.GetNetType(ramlType.Scalar.Type, ramlType.Scalar.Format);
if (type != null)
{
return(type);
}
if (!ramlTypes.ContainsKey(ramlType.Scalar.Type))
{
return("object");
}
var subRamlType = ramlTypes[ramlType.Scalar.Type];
if (subRamlType.Scalar == null)
{
return(NetNamingMapper.GetObjectName(ramlType.Scalar.Type));
}
type = GetScalarType(subRamlType);
if (type != null)
{
return(type);
}
throw new InvalidOperationException("Cannot determine type of scalar " + ramlType.Name);
}
public static IList <Property> ConvertHeadersToProperties(IDictionary <string, Parameter> headers)
{
var properties = new List <Property>();
if (headers == null)
{
return(properties);
}
foreach (var header in headers)
{
var description = ParserHelpers.RemoveNewLines(header.Value.Description);
var type = NetTypeMapper.GetNetType(header.Value.Type, header.Value.Format);
var typeSuffix = (type == "string" || header.Value.Required ? "" : "?");
properties.Add(new Property
{
Type = type + typeSuffix,
Name = NetNamingMapper.GetPropertyName(header.Key),
OriginalName = header.Value.DisplayName,
Description = description,
Example = header.Value.Example,
Required = header.Value.Required
});
}
return(properties);
}
private IEnumerable <GeneratorParameter> MatchParameters(IDictionary <string, Parameter> parentUriParameters, GeneratorParameter[] urlParameters)
{
var parameters = new List <GeneratorParameter>();
foreach (var param in urlParameters)
{
if (parentUriParameters.ContainsKey(param.Name))
{
param.Type = NetTypeMapper.GetNetType(parentUriParameters[param.Name].Type, parentUriParameters[param.Name].Format);
param.Description = parentUriParameters[param.Name].Description;
}
parameters.Add(param);
}
return(parameters);
}
private string GetPropertyType(RamlType prop, KeyValuePair <string, RamlType> kv)
{
if (string.IsNullOrWhiteSpace(prop.Type))
{
return("string");
}
if (prop.Type == "object" || (prop.Scalar.Enum != null && prop.Scalar.Enum.Any()))
{
return(NetNamingMapper.GetPropertyName(kv.Key));
}
var propertyType = NetTypeMapper.GetNetType(prop.Scalar.Type, prop.Scalar.Format);
if (propertyType != null)
{
if (!prop.Required && !prop.Scalar.Required && propertyType != "string" && prop.Type != "file")
{
return(propertyType + "?");
}
return(propertyType);
}
if (schemaObjects.ContainsKey(prop.Type))
{
var obj = schemaObjects[prop.Type];
if (obj.IsScalar)
{
return(obj.Properties.First().Type);
}
return(obj.Type);
}
if (enums.ContainsKey(prop.Type))
{
return(prop.Type);
}
return("object");
}
private string GetParameterType(KeyValuePair <string, Parameter> parameter)
{
var parameterType = NetTypeMapper.GetNetType(parameter.Value.Type, parameter.Value.Format);
if (parameterType != null)
{
return(parameterType);
}
if (schemaObjects.ContainsKey(parameter.Value.Type))
{
var schemaObject = schemaObjects[parameter.Value.Type];
if (schemaObject.IsScalar)
{
return(schemaObject.Properties.First().Type);
}
return(schemaObject.Type);
}
return("object");
}
public IEnumerable <GeneratorParameter> GetUriParameters(Resource resource, string url, IDictionary <string, Parameter> parentUriParameters)
{
var parameters = resource.BaseUriParameters
.Select(p => new GeneratorParameter {
Name = p.Key, Type = NetTypeMapper.GetNetType(p.Value.Type, p.Value.Format), Description = p.Value.Description
})
.ToList();
parameters.AddRange(resource.UriParameters
.Select(p => new GeneratorParameter {
Name = p.Key, Type = GetParameterType(p), Description = p.Value.Description
})
.ToList());
var urlParameters = ExtractParametersFromUrl(url).ToArray();
var distincUrlParameters = urlParameters.Where(up => parameters.All(p => up.Name != p.Name)).ToArray();
var matchedParameters = MatchParameters(parentUriParameters, distincUrlParameters);
parameters.AddRange(matchedParameters);
return(parameters);
}
private string GetType(Parameter param)
{
if (param.Type == null)
{
return("string");
}
if (NetTypeMapper.IsPrimitiveType(param.Type))
{
return(NetTypeMapper.GetNetType(param.Type, param.Format) +
(NetTypeMapper.GetNetType(param.Type, param.Format) == "string" || param.Required ? "" : "?"));
}
var pureType = RamlTypesHelper.ExtractType(param.Type);
if (schemaObjects.ContainsKey(pureType))
{
var apiObject = schemaObjects[pureType];
return(RamlTypesHelper.GetTypeFromApiObject(apiObject));
}
return(RamlTypesHelper.DecodeRaml1Type(param.Type));
}