private static ClientGeneratorModel GetGeneratorModel(string wszInputFilePath, RamlInfo ramlInfo) { var rootName = NetNamingMapper.GetObjectName(Path.GetFileNameWithoutExtension(wszInputFilePath)); if (!rootName.ToLower().Contains("api")) { rootName += "Api"; } var model = new ClientGeneratorService(ramlInfo.RamlDocument, rootName).BuildModel(); return(model); }
public static string DecodeRaml1Type(string type) { // TODO: can I handle this better ? if (type.Contains("(") || type.Contains("|")) { return("object"); } if (type.EndsWith("[][]")) // array of arrays { var strippedType = type.Substring(0, type.Length - 4); if (NewNetTypeMapper.Map(strippedType) == null) { strippedType = NetNamingMapper.GetObjectName(strippedType); } var decodeRaml1Type = CollectionTypeHelper.GetCollectionType(CollectionTypeHelper.GetCollectionType(strippedType)); return(decodeRaml1Type); } if (type.EndsWith("[]")) // array { var strippedType = type.Substring(0, type.Length - 2); if (NewNetTypeMapper.Map(strippedType) == null) { strippedType = NetNamingMapper.GetObjectName(strippedType); } var decodeRaml1Type = CollectionTypeHelper.GetCollectionType(strippedType); return(decodeRaml1Type); } if (type.EndsWith("{}")) // Map { var subtype = type.Substring(0, type.Length - 2); var netType = NewNetTypeMapper.Map(subtype); if (netType != null) { return("IDictionary<string, " + netType + ">"); } return("IDictionary<string, " + NetNamingMapper.GetObjectName(subtype) + ">"); } if (CollectionTypeHelper.IsCollection(type)) { return(type); } return(NetNamingMapper.GetObjectName(type)); }
private ApiEnum CreateEnum(ScalarShape scalar, IDictionary <string, ApiEnum> existingEnums, IDictionary <string, string> warnings, IDictionary <string, ApiEnum> newEnums) { return(new ApiEnum { Name = NetNamingMapper.GetObjectName(scalar.Name), Description = scalar.Description, Values = scalar.Values.Distinct() .Select(p => new PropertyBase { Name = NetNamingMapper.GetEnumValueName(p), OriginalName = p.Replace("\\", "\\\\") }) .ToArray() }); }
private static string GetCollectionType(Property prop, string itemType) { if (NewNetTypeMapper.IsPrimitiveType(itemType)) { return(CollectionTypeHelper.GetCollectionType(itemType)); } if (CollectionTypeHelper.IsCollection(itemType)) { return(CollectionTypeHelper.GetCollectionType(itemType)); } return(CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(itemType))); }
private void ParseComplexTypes(IDictionary <string, ApiObject> objects, Newtonsoft.JsonV4.Schema.JsonSchema schema, Newtonsoft.JsonV4.Schema.JsonSchema propertySchema, Property prop, KeyValuePair <string, Newtonsoft.JsonV4.Schema.JsonSchema> property, IDictionary <string, ApiEnum> enums) { if (propertySchema.Type.HasValue && (propertySchema.Type == Newtonsoft.JsonV4.Schema.JsonSchemaType.Object || propertySchema.Type.Value.ToString().Contains("Object")) && propertySchema.Properties != null) { if (!string.IsNullOrWhiteSpace(schema.Id) && ids.Contains(schema.Id)) { return; } if (!string.IsNullOrWhiteSpace(schema.Id)) { ids.Add(schema.Id); } var type = string.IsNullOrWhiteSpace(property.Value.Id) ? property.Key : property.Value.Id; ParseObject(type, propertySchema.Properties, objects, enums, propertySchema); prop.Type = NetNamingMapper.GetObjectName(type); } else if (propertySchema.Type.HasValue && propertySchema.Type == Newtonsoft.JsonV4.Schema.JsonSchemaType.Object && propertySchema.OneOf != null && propertySchema.OneOf.Count > 0 && schema.Definitions != null && schema.Definitions.Count > 0) { string baseTypeName = NetNamingMapper.GetObjectName(property.Key); if (schemaObjects.ContainsKey(baseTypeName) || objects.ContainsKey(baseTypeName) || otherObjects.ContainsKey(baseTypeName)) { return; } objects.Add(baseTypeName, new ApiObject { Name = baseTypeName, Properties = new List <Property>() }); foreach (var innerSchema in propertySchema.OneOf) { var definition = schema.Definitions.FirstOrDefault(k => k.Value == innerSchema); ParseObject(property.Key + definition.Key, innerSchema.Properties, objects, enums, innerSchema, baseTypeName); } prop.Type = baseTypeName; } else if (propertySchema.Type == Newtonsoft.JsonV4.Schema.JsonSchemaType.Array) { ParseArray(objects, propertySchema, prop, property, enums); } }
public void Generate(EndPoint 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.Parameters != null) { properties.AddRange(queryParametersParser.ConvertParametersToProperties(resource.Parameters)); } 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.Path, Properties = properties }; uriParameterObjects.Add(name, apiObject); }
private static string GetType(KeyValuePair <string, JsonSchema> property, bool isEnum, string enumName) { if (isEnum) { return(enumName); } var type = NetTypeMapper.Map(property.Value.Type); if (!string.IsNullOrWhiteSpace(type)) { if (type == "string" || (property.Value.Required != null && property.Value.Required.Value)) { return(type); } return(type + "?"); } if (HasMultipleTypes(property)) { return(HandleMultipleTypes(property)); } if (!string.IsNullOrWhiteSpace(property.Value.Id)) { return(NetNamingMapper.GetObjectName(property.Value.Id)); } // if it is a "body less" array then I assume it's an array of strings if (property.Value.Type == JsonSchemaType.Array && (property.Value.Items == null || !property.Value.Items.Any())) { return(CollectionTypeHelper.GetCollectionType("string")); } // if it is a "body less" object then use object as the type if (property.Value.Type == JsonSchemaType.Object && (property.Value.Properties == null || !property.Value.Properties.Any())) { return("object"); } if (property.Value == null) { return(null); } return(NetNamingMapper.GetObjectName(property.Key)); }
private void ParseArray(IDictionary <string, ApiObject> objects, Newtonsoft.JsonV4.Schema.JsonSchema schema, Property prop, KeyValuePair <string, Newtonsoft.JsonV4.Schema.JsonSchema> property, IDictionary <string, ApiEnum> enums) { var netType = NetTypeMapper.Map(schema.Items.First().Type); if (netType != null) { prop.Type = CollectionTypeHelper.GetCollectionType(netType); } else { prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(property.Key)); foreach (var item in schema.Items) { ParseObject(property.Key, item.Properties, objects, enums, item); } } }
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; }
public ApiObject Parse(string key, string schema, IDictionary <string, ApiObject> objects, string modelsNamespace) { var codeNamespace = Process(schema, modelsNamespace); var code = GenerateCode(codeNamespace); if (HasDuplicatedObjects(objects, codeNamespace)) { return(null); } if (codeNamespace.Types.Count == 0) { return(null); } return(new ApiObject { Name = NetNamingMapper.GetObjectName(key), GeneratedCode = code }); }
private string ParseObject(string key, IDictionary <string, JsonSchema> schema, IDictionary <string, ApiObject> objects, IDictionary <string, ApiEnum> enums) { if (schema == null) { return(null); } var obj = new ApiObject { Name = NetNamingMapper.GetObjectName(key), Properties = ParseSchema(schema, objects, enums) }; if (obj == null) { return(null); } if (!obj.Properties.Any()) { return(null); } // Avoid duplicated keys and names or no properties if (objects.ContainsKey(key) || objects.Any(o => o.Value.Name == obj.Name) || otherObjects.ContainsKey(key) || otherObjects.Any(o => o.Value.Name == obj.Name) || schemaObjects.ContainsKey(key) || schemaObjects.Any(o => o.Value.Name == obj.Name)) { if (UniquenessHelper.HasSameProperties(obj, objects, key, otherObjects, schemaObjects)) { return(key); } obj.Name = UniquenessHelper.GetUniqueName(objects, obj.Name, otherObjects, schemaObjects); key = UniquenessHelper.GetUniqueKey(objects, key, otherObjects); } objects.Add(key, obj); return(key); }
private static string GetType(KeyValuePair <string, Newtonsoft.JsonV4.Schema.JsonSchema> property, bool isEnum, string enumName, ICollection <string> requiredProps) { if (property.Value.OneOf != null && property.Value.OneOf.Count > 0) { return(NetNamingMapper.GetObjectName(property.Key)); } if (isEnum) { return(enumName); } var type = NetTypeMapper.Map(property.Value.Type); if (!string.IsNullOrWhiteSpace(type)) { if (type == "string" || (requiredProps != null && requiredProps.Contains(property.Key))) { return(type); } return(type + "?"); } if (HasMultipleTypes(property)) { return(HandleMultipleTypes(property)); } if (!string.IsNullOrWhiteSpace(property.Value.Id)) { return(NetNamingMapper.GetObjectName(property.Value.Id)); } return(NetNamingMapper.GetObjectName(property.Key)); }
public void Should_Avoid_Brackets_In_Object_Name() { Assert.Equal("Sales", NetNamingMapper.GetObjectName("sales[]")); Assert.Equal("Salesperson", NetNamingMapper.GetObjectName("(sales|person)[]")); }
public void Should_Convert_Object_Names() { Assert.Equal("GetSalesId", NetNamingMapper.GetObjectName("get-/sales/{id}")); }
public void Should_Avoid_Single_Quote_In_Object_Name() { Assert.Equal("GetSalesId", NetNamingMapper.GetObjectName("get-/sales('{id}')")); Assert.Equal("GetSalesId", NetNamingMapper.GetObjectName("get-/sales'id'")); }
private bool ResponseHasKey(string key) { return(schemaObjects.ContainsKey(key) || schemaResponseObjects.ContainsKey(key) || schemaObjects.ContainsKey(NetNamingMapper.GetObjectName(key)) || schemaResponseObjects.ContainsKey(NetNamingMapper.GetObjectName(key))); }
private Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> > ParseObject(Guid id, string key, Shape shape, IDictionary <string, ApiObject> existingObjects, bool isRootType) { if (AlreadyExists(existingObjects, existingEnums, shape.Id)) { return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> > (newObjects, newEnums, new Dictionary <Guid, string>())); } // if is array of scalar or array of object there's no new object, except when is a root type if (!isRootType && shape is ArrayShape array && (array.Items is ScalarShape || array.Items is AnyShape)) { return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> > (newObjects, newEnums, new Dictionary <Guid, string>())); } var linkedType = new Dictionary <Guid, string>(); var apiObj = new ApiObject { Id = id, AmfId = shape.Id, BaseClass = GetBaseClass(shape), IsArray = shape is ArrayShape, IsScalar = shape is ScalarShape, IsUnionType = shape is UnionShape, Name = NetNamingMapper.GetObjectName(key), Type = NetNamingMapper.GetObjectName(key), Description = shape.Description, Example = MapExample(shape) }; if (isRootType && apiObj.IsScalar) { apiObj.Type = NewNetTypeMapper.GetNetType(shape, existingObjects); } if (isRootType && apiObj.IsArray && shape is ArrayShape arrShape) { var itemShape = arrShape.Items; if (itemShape is NodeShape) { var itemId = Guid.NewGuid(); ParseObject(itemId, itemShape.Name, itemShape, existingObjects, false); apiObj.Type = NewNetTypeMapper.GetNetType(shape, existingObjects); } else { //if (newObjects.ContainsKey(itemShape.Id)) // apiObj.Type = CollectionTypeHelper.GetCollectionType(newObjects[itemShape.Id].Type); //else if(existingObjects.ContainsKey(itemShape.Id)) // apiObj.Type = CollectionTypeHelper.GetCollectionType(existingObjects[itemShape.Id].Type); //else apiObj.Type = NewNetTypeMapper.GetNetType(shape, existingObjects); } } if (shape is NodeShape node && node.Properties.Count() == 1 && node.Properties.First().Path != null && node.Properties.First().Path.StartsWith("/") && node.Properties.First().Path.EndsWith("/")) { apiObj.IsMap = true; var valueType = "object"; if (node.Properties.First().Range != null) { valueType = NewNetTypeMapper.GetNetType(node.Properties.First().Range, existingObjects); } apiObj.Type = $"Dictionary<string, {valueType}>"; AddNewObject(shape, apiObj); return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType)); } apiObj.Properties = MapProperties(shape, apiObj.Name).ToList(); ApiObject match = null; if (existingObjects.Values.Any(o => o.Name == apiObj.Name) || newObjects.Values.Any(o => o.Name == apiObj.Name)) { if (UniquenessHelper.HasSameProperties(apiObj, existingObjects, key, newObjects, emptyDic)) { return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType)); } match = HandleNameDuplication(id, apiObj, key, linkedType); } if (existingObjects.Values.Any(o => o.Type == apiObj.Type) || newObjects.Values.Any(o => o.Type == apiObj.Type)) { if (UniquenessHelper.HasSameProperties(apiObj, existingObjects, key, newObjects, emptyDic)) { return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType)); } match = HandleTypeDuplication(id, apiObj, key, linkedType); } if (match != null) { return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType)); } //if (match == null) //{ // match = UniquenessHelper.FirstOrDefaultWithSameProperties(apiObj, existingObjects, key, newObjects, emptyDic); // if (match != null) // { // if (!linkedType.ContainsKey(id)) // linkedType.Add(id, match.Type); // } //} if (shape.Inherits != null && shape.Inherits.Count() == 1) { var baseClass = NewNetTypeMapper.GetNetType(shape.Inherits.First(), existingObjects, newObjects, existingEnums, newEnums); if (!string.IsNullOrWhiteSpace(baseClass)) { apiObj.BaseClass = CollectionTypeHelper.GetConcreteType(baseClass); } } AddNewObject(shape, apiObj); return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum>, IDictionary <Guid, string> >(newObjects, newEnums, linkedType)); }
private Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum> > ParseObject(string key, Shape shape, IDictionary <string, ApiObject> existingObjects, bool isRootType) { var apiObj = new ApiObject { BaseClass = GetBaseClass(shape), IsArray = shape is ArrayShape, IsScalar = shape is ScalarShape, IsUnionType = shape is UnionShape, Name = NetNamingMapper.GetObjectName(key), Type = NetNamingMapper.GetObjectName(key), Description = shape.Description, Example = MapExample(shape) }; if (isRootType && (apiObj.IsArray || apiObj.IsScalar)) { apiObj.Type = NewNetTypeMapper.GetNetType(shape, existingObjects); } if (shape is NodeShape node && node.Properties.Count() == 1 && node.Properties.First().Path.StartsWith("/") && node.Properties.First().Path.EndsWith("/")) { apiObj.IsMap = true; var valueType = "object"; if (node.Properties.First().Range != null) { valueType = NewNetTypeMapper.GetNetType(node.Properties.First().Range, existingObjects); } apiObj.Type = $"Dictionary<string, {valueType}>"; new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum> >(newObjects, newEnums); } apiObj.Properties = MapProperties(shape, apiObj.Name).ToList(); if (existingObjects.Values.Any(o => o.Name == apiObj.Name)) { if (UniquenessHelper.HasSameProperties(apiObj, existingObjects, key, new Dictionary <string, ApiObject>(), new Dictionary <string, ApiObject>())) { return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum> >(newObjects, newEnums)); } apiObj.Name = UniquenessHelper.GetUniqueName(existingObjects, apiObj.Name, new Dictionary <string, ApiObject>(), new Dictionary <string, ApiObject>()); foreach (var prop in apiObj.Properties) { prop.ParentClassName = apiObj.Name; } } if (existingObjects.Values.Any(o => o.Type == apiObj.Type)) { if (UniquenessHelper.HasSameProperties(apiObj, existingObjects, key, new Dictionary <string, ApiObject>(), new Dictionary <string, ApiObject>())) { return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum> >(newObjects, newEnums)); } apiObj.Type = UniquenessHelper.GetUniqueName(existingObjects, apiObj.Type, new Dictionary <string, ApiObject>(), new Dictionary <string, ApiObject>()); } if (!newObjects.ContainsKey(apiObj.Type)) { newObjects.Add(apiObj.Type, apiObj); } return(new Tuple <IDictionary <string, ApiObject>, IDictionary <string, ApiEnum> >(newObjects, newEnums)); }
public static string GetNetType(Shape shape, IDictionary <string, ApiObject> existingObjects = null, IDictionary <string, ApiObject> newObjects = null, IDictionary <string, ApiEnum> existingEnums = null, IDictionary <string, ApiEnum> newEnums = null) { if (!string.IsNullOrWhiteSpace(shape.LinkTargetName)) { return(NetNamingMapper.GetObjectName(GetTypeFromLinkOrId(shape.LinkTargetName))); } if (shape is ScalarShape scalar) { if (shape.Values != null && shape.Values.Any()) { var key = GetTypeFromLinkOrId(shape.Id); if (existingEnums != null && existingEnums.ContainsKey(key)) { return(existingEnums[key].Name); } if (newEnums != null && newEnums.ContainsKey(key)) { return(newEnums[key].Name); } } return(GetNetType(scalar.DataType.Substring(scalar.DataType.LastIndexOf('#') + 1), scalar.Format)); } if (shape is ArrayShape array) { return(CollectionTypeHelper.GetCollectionType(GetNetType(array.Items, existingObjects, newObjects, existingEnums, newEnums))); } if (shape is FileShape file) { return(TypeStringConversion["file"]); } if (shape.Id.Contains("#/declarations")) { var key = GetTypeFromLinkOrId(shape.Id); if (existingObjects != null && (existingObjects.ContainsKey(key) || existingObjects.Keys.Any(k => k.ToLowerInvariant() == key.ToLowerInvariant()))) { if (existingObjects.ContainsKey(key)) { return(existingObjects[key].Type); } return(existingObjects.First(kv => kv.Key.ToLowerInvariant() == key.ToLowerInvariant()).Value.Type); } if (newObjects != null && newObjects.ContainsKey(key)) { return(newObjects[key].Type); } } if (shape.Inherits.Count() == 1) { if (shape is NodeShape nodeShape) { if (nodeShape.Properties.Count() == 0) { return(GetNetType(nodeShape.Inherits.First(), existingObjects, newObjects, existingEnums, newEnums)); } } if (shape.Inherits.First() is ArrayShape arrayShape) { return(CollectionTypeHelper.GetCollectionType(GetNetType(arrayShape.Items, existingObjects, newObjects, existingEnums, newEnums))); } if (shape is AnyShape any) { var key = NetNamingMapper.GetObjectName(any.Inherits.First().Name); if (existingObjects != null && existingObjects.ContainsKey(key)) { return(key); } if (newObjects != null && newObjects.ContainsKey(key)) { return(key); } } } if (shape.Inherits.Count() > 0) { //TODO: check } if (shape.GetType() == typeof(AnyShape)) { return(GetNetType("any", null)); } if (shape is UnionShape) { return("object"); } return(NetNamingMapper.GetObjectName(shape.Name)); }
public ApiObject Parse(string key, string jsonSchema, IDictionary <string, ApiObject> objects, IDictionary <string, string> warnings, IDictionary <string, ApiEnum> enums, IDictionary <string, ApiObject> otherObjects, IDictionary <string, ApiObject> schemaObjects) { this.otherObjects = otherObjects; this.schemaObjects = schemaObjects; var obj = new ApiObject { Name = NetNamingMapper.GetObjectName(key), Properties = new List <Property>(), JSONSchema = jsonSchema.Replace(Environment.NewLine, "").Replace("\r\n", "").Replace("\n", "") .Replace("\\", "\\\\").Replace("\"", "\\\"") // .Replace("\\/", "\\\\/").Replace("\"", "\\\"").Replace("\\\\\"", "\\\\\\\"") }; JsonSchema schema = null; Newtonsoft.JsonV4.Schema.JsonSchema v4Schema = null; if (jsonSchema.Contains("\"oneOf\"")) { v4Schema = ParseV4Schema(key, jsonSchema, warnings, objects); } else { schema = ParseV3OrV4Schema(key, jsonSchema, warnings, ref v4Schema, objects); } if (schema == null && v4Schema == null) { return(obj); } if (schema != null) { if (schema.Type == JsonSchemaType.Array) { obj.IsArray = true; if (schema.Items != null && schema.Items.Any()) { if (schema.Items.First().Properties != null) { ParseProperties(objects, obj.Properties, schema.Items.First().Properties, enums); } else { obj.Type = NetTypeMapper.Map(schema.Items.First().Type); } } } else { ParseProperties(objects, obj.Properties, schema.Properties, enums); AdditionalProperties(obj.Properties, schema); } } else { if (v4Schema.Type == Newtonsoft.JsonV4.Schema.JsonSchemaType.Array) { obj.IsArray = true; if (v4Schema.Items != null && v4Schema.Items.Any()) { if (v4Schema.Items.First().Properties != null) { ParseProperties(objects, obj.Properties, v4Schema.Items.First(), enums); } else { obj.Type = NetTypeMapper.Map(v4Schema.Items.First().Type); } } } else { ParseProperties(objects, obj.Properties, v4Schema, enums); } } return(obj); }
private string DecodeResponseRaml1Type(string type) { // TODO: can I handle this better ? if (type.Contains("(") || type.Contains("|")) { return("string"); } if (type.EndsWith("[][]")) // array of arrays { var subtype = type.Substring(0, type.Length - 4); if (NewNetTypeMapper.IsPrimitiveType(subtype)) { subtype = NewNetTypeMapper.Map(subtype); } else { subtype = NetNamingMapper.GetObjectName(subtype); } return(CollectionTypeHelper.GetCollectionType(CollectionTypeHelper.GetCollectionType(subtype))); } if (type.EndsWith("[]")) // array { var subtype = type.Substring(0, type.Length - 2); if (NewNetTypeMapper.IsPrimitiveType(subtype)) { subtype = NewNetTypeMapper.Map(subtype); } else { subtype = NetNamingMapper.GetObjectName(subtype); } return(CollectionTypeHelper.GetCollectionType(subtype)); } if (type.EndsWith("{}")) // Map { var subtype = type.Substring(0, type.Length - 2); var netType = NewNetTypeMapper.Map(subtype); if (!string.IsNullOrWhiteSpace(netType)) { return("IDictionary<string, " + netType + ">"); } var objectType = GetReturnTypeFromName(subtype); if (!string.IsNullOrWhiteSpace(objectType)) { return("IDictionary<string, " + objectType + ">"); } return("IDictionary<string, object>"); } if (NewNetTypeMapper.IsPrimitiveType(type)) { return(NewNetTypeMapper.Map(type)); } return(type); }
public GeneratorParameter GetRequestParameter(string key, Operation method, EndPoint resource, string fullUrl, IEnumerable <string> defaultMediaTypes) { if (method.Request == null || !method.Request.Payloads.Any()) { return new GeneratorParameter { Name = "content", Type = "string" } } ; var mimeType = GetMimeType(method.Request.Payloads, defaultMediaTypes); var type = NewNetTypeMapper.GetNetType(mimeType, schemaObjects, null, enums); if (RamlTypesHelper.IsPrimitiveOrSchemaObject(type, schemaObjects)) { return(new GeneratorParameter //TODO: check { Name = string.IsNullOrWhiteSpace(mimeType.Name) ? GetParameterName(type) : GetParameterName(mimeType.Name), Description = mimeType.Description, Type = type }); } var apiObjectByKey = GetRequestApiObjectByKey(key); if (apiObjectByKey != null) { return(CreateGeneratorParameter(apiObjectByKey)); } apiObjectByKey = GetRequestApiObjectByKey(NetNamingMapper.GetObjectName(key)); if (apiObjectByKey != null) { return(CreateGeneratorParameter(apiObjectByKey)); } var requestKey = key + GeneratorServiceBase.RequestContentSuffix; apiObjectByKey = GetRequestApiObjectByKey(requestKey); if (apiObjectByKey != null) { return(CreateGeneratorParameter(apiObjectByKey)); } if (linkKeysWithObjectNames.ContainsKey(key)) { var linkedKey = linkKeysWithObjectNames[key]; apiObjectByKey = GetRequestApiObjectByKey(linkedKey); if (apiObjectByKey != null) { return(CreateGeneratorParameter(apiObjectByKey)); } } if (linkKeysWithObjectNames.ContainsKey(requestKey)) { var linkedKey = linkKeysWithObjectNames[requestKey]; apiObjectByKey = GetRequestApiObjectByKey(linkedKey); if (apiObjectByKey != null) { return(CreateGeneratorParameter(apiObjectByKey)); } } return(new GeneratorParameter { Name = "content", Type = "string" }); //if (mimeType != null) //{ // if (mimeType.Type != "object" && !string.IsNullOrWhiteSpace(mimeType.Type)) // { // var apiObject = GetRequestApiObjectWhenNamed(method, resource, mimeType.Type, fullUrl); // if (apiObject != null) // { // var generatorParameter = new GeneratorParameter // { // Name = apiObject.Name.ToLower(), // Type = GetParamType(mimeType, apiObject), // //Type = DecodeRequestRaml1Type(RamlTypesHelper.GetTypeFromApiObject(apiObject)), // Description = apiObject.Description // }; // return generatorParameter; // } // } // if (!string.IsNullOrWhiteSpace(mimeType.Schema)) // { // var apiObject = GetRequestApiObjectWhenNamed(method, resource, mimeType.Schema, fullUrl); // if (apiObject != null) // return CreateGeneratorParameter(apiObject); // } //} //if (resource.Type != null && resource.Type.Any() && // resourceTypes.Any(rt => rt.ContainsKey(resource.GetSingleType()))) //{ // var verb = RamlTypesHelper.GetResourceTypeVerb(method, resource, resourceTypes); // if (verb != null && verb.Body != null && !string.IsNullOrWhiteSpace(verb.Body.Schema)) // { // var apiObject = GetRequestApiObjectWhenNamed(method, resource, verb.Body.Schema, fullUrl); // if (apiObject != null) // return CreateGeneratorParameter(apiObject); // } // if (verb != null && verb.Body != null && !string.IsNullOrWhiteSpace(verb.Body.Type)) // { // var apiObject = GetRequestApiObjectWhenNamed(method, resource, verb.Body.Type, fullUrl); // if (apiObject != null) // { // var generatorParameter = new GeneratorParameter // { // Name = apiObject.Name.ToLower(), // Type = DecodeRequestRaml1Type(RamlTypesHelper.GetTypeFromApiObject(apiObject)), // Description = apiObject.Description // }; // return generatorParameter; // } // return new GeneratorParameter { Name = "content", Type = DecodeRequestRaml1Type(verb.Body.Type) }; // } //} //if (mimeType != null) //{ // string type; // if(!string.IsNullOrWhiteSpace(mimeType.Type)) // type = mimeType.Type; // else // type = mimeType.Schema; // if (!string.IsNullOrWhiteSpace(type)) // { // var raml1Type = DecodeRequestRaml1Type(type); // if (!string.IsNullOrWhiteSpace(raml1Type)) // return new GeneratorParameter {Name = "content", Type = raml1Type}; // } //} //return new GeneratorParameter { Name = "content", Type = "string" }; }
private void SetNamespace(string fileName) { Namespace = VisualStudioAutomationHelper.GetDefaultNamespace(ServiceProvider) + "." + NetNamingMapper.GetObjectName(Path.GetFileNameWithoutExtension(fileName)); }
public void Should_Remove_QuestionMark_From_Object_Name() { Assert.Equal("Optional", NetNamingMapper.GetObjectName("optional?")); }
private Property MapProperty(PropertyShape p, string parentClassName) { var name = GetPropertyName(p); var prop = new Property(parentClassName) { Name = NetNamingMapper.GetPropertyName(name), Required = p.Required, Type = NetNamingMapper.GetObjectName(name), InheritanceProvenance = p.InheritanceProvenance }; if (p.Range == null) { return(prop); } prop.OriginalName = p.Range.Name; prop.AmfId = p.Range.Id; prop.Description = p.Range.Description; prop.Example = MapExample(p.Range); prop.Type = NewNetTypeMapper.GetNetType(p.Range, existingObjects, newObjects, existingEnums, newEnums); if (p.Range is ScalarShape scalar) { prop.Pattern = scalar.Pattern; prop.MaxLength = scalar.MaxLength; prop.MinLength = scalar.MinLength; prop.Maximum = string.IsNullOrWhiteSpace(scalar.Maximum) ? (double?)null : Convert.ToDouble(scalar.Maximum); prop.Minimum = string.IsNullOrWhiteSpace(scalar.Minimum) ? (double?)null : Convert.ToDouble(scalar.Minimum); if (scalar.Values != null && scalar.Values.Any()) { prop.IsEnum = true; var apiEnum = CreateEnum(scalar, existingEnums, warnings, newEnums); string amfId = apiEnum.AmfId; if (string.IsNullOrWhiteSpace(amfId)) { amfId = prop.AmfId ?? prop.Name; } prop.Type = apiEnum.Name; if (newEnums.ContainsKey(amfId)) { return(prop); } if (existingEnums.Values.Any(o => o.Name == apiEnum.Name) || newEnums.Values.Any(o => o.Name == apiEnum.Name)) { if (UniquenessHelper.HasSamevalues(apiEnum, existingEnums, newEnums)) { return(prop); } apiEnum.Name = UniquenessHelper.GetUniqueName(apiEnum.Name, existingEnums, newEnums); prop.Type = apiEnum.Name; } newEnums.Add(amfId, apiEnum); } return(prop); } //if (existingObjects.ContainsKey(prop.Type) || newObjects.ContainsKey(prop.Type)) // return prop; if (p.Range is NodeShape) { if (existingObjects.ContainsKey(p.Range.Id)) { prop.Type = existingObjects[p.Range.Id].Type; return(prop); } if (newObjects.ContainsKey(p.Range.Id)) { prop.Type = newObjects[p.Range.Id].Type; return(prop); } var id = Guid.NewGuid(); prop.TypeId = id; var tuple = ParseObject(id, prop.Name, p.Range, existingObjects, warnings, existingEnums); prop.Type = NetNamingMapper.GetObjectName(prop.Name); } if (p.Range is ArrayShape array) { if (array.Items is ScalarShape) { return(prop); } if (!string.IsNullOrWhiteSpace(array.Items.LinkTargetName)) { return(prop); } var itemType = NewNetTypeMapper.GetNetType(array.Items, existingObjects, newObjects, existingEnums, newEnums); GetCollectionType(prop, itemType); if (array.Items is NodeShape && itemType == "Items") { itemType = NetNamingMapper.GetObjectName(array.Name); prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(array.Name)); } if (existingObjects.ContainsKey(array.Id)) { return(prop); } if (array.Items is ScalarShape || array.Items.GetType() == typeof(AnyShape)) { return(prop); } var newId = Guid.NewGuid(); prop.TypeId = newId; ParseObject(newId, array.Name, array.Items, existingObjects, warnings, existingEnums); } foreach (var parent in p.Range.Inherits) { if (!(parent is ScalarShape) && !NewNetTypeMapper.IsPrimitiveType(prop.Type) && !(CollectionTypeHelper.IsCollection(prop.Type) && NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(prop.Type))) && string.IsNullOrWhiteSpace(parent.LinkTargetName)) { var newId = Guid.NewGuid(); ParseObject(newId, prop.Name, parent, existingObjects, warnings, existingEnums); } } return(prop); }
public void Should_Remove_MediaTypeExtension_From_Method_Name() { Assert.Equal("Users", NetNamingMapper.GetObjectName("users{mediaTypeExtension}")); }
private Property MapProperty(PropertyShape p, string parentClassName) { var prop = new Property(parentClassName) { Name = NetNamingMapper.GetObjectName(GetNameFromPath(p.Path)), Required = p.Required, Type = NetNamingMapper.GetObjectName(GetNameFromPath(p.Path)) //TODO: check }; if (p.Range == null) { return(prop); } prop.Name = NetNamingMapper.GetObjectName(string.IsNullOrWhiteSpace(p.Path) ? p.Range.Name : GetNameFromPath(p.Path)); prop.Description = p.Range.Description; prop.Example = MapExample(p.Range); prop.Type = NewNetTypeMapper.GetNetType(p.Range, existingObjects, newObjects, existingEnums, newEnums); if (p.Range is ScalarShape scalar) { prop.Pattern = scalar.Pattern; prop.MaxLength = scalar.MaxLength; prop.MinLength = scalar.MinLength; prop.Maximum = string.IsNullOrWhiteSpace(scalar.Maximum) ? (double?)null : Convert.ToDouble(scalar.Maximum); prop.Minimum = string.IsNullOrWhiteSpace(scalar.Minimum) ? (double?)null : Convert.ToDouble(scalar.Minimum); if (scalar.Values != null && scalar.Values.Any()) { // enum ?? prop.IsEnum = true; var apiEnum = ParseEnum(scalar, existingEnums, warnings, newEnums); if (!newEnums.ContainsKey(apiEnum.Name)) { newEnums.Add(apiEnum.Name, apiEnum); } prop.Type = apiEnum.Name; } return(prop); } if (existingObjects.ContainsKey(prop.Type) || newObjects.ContainsKey(prop.Type)) { return(prop); } if (p.Range is NodeShape) { var tuple = ParseObject(prop.Name, p.Range, existingObjects, warnings, existingEnums); prop.Type = NetNamingMapper.GetObjectName(prop.Name); } if (p.Range is ArrayShape array) { if (array.Items is ScalarShape) { return(prop); } var itemType = NewNetTypeMapper.GetNetType(array.Items, existingObjects, newObjects, existingEnums, newEnums); prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(itemType)); if (array.Items is NodeShape && itemType == "Items") { itemType = NetNamingMapper.GetObjectName(array.Name); prop.Type = CollectionTypeHelper.GetCollectionType(NetNamingMapper.GetObjectName(array.Name)); } if (existingObjects.ContainsKey(itemType) || newObjects.ContainsKey(itemType)) { return(prop); } ParseObject(array.Name, array.Items, existingObjects, warnings, existingEnums); } foreach (var parent in p.Range.Inherits) { if (!(parent is ScalarShape) && !NewNetTypeMapper.IsPrimitiveType(prop.Type) && !(CollectionTypeHelper.IsCollection(prop.Type) && NewNetTypeMapper.IsPrimitiveType(CollectionTypeHelper.GetBaseType(prop.Type))) && string.IsNullOrWhiteSpace(parent.LinkTargetName)) { ParseObject(prop.Name, parent, existingObjects, warnings, existingEnums); } } return(prop); }
public void Should_Avoid_Parentheses_In_Object_Name() { Assert.Equal("GetSalesId", NetNamingMapper.GetObjectName("get-/sales({id})")); Assert.Equal("GetSalesId", NetNamingMapper.GetObjectName("get-/sales(id)")); }
protected string GetUniqueObjectName(RAML.Parser.Model.EndPoint resource, RAML.Parser.Model.EndPoint parent) { string objectName; if (resource.Path.StartsWith("/{") && resource.Path.EndsWith("}")) { objectName = NetNamingMapper.Capitalize(GetObjectNameForParameter(resource)); } else { if (resource.Path == "/") { objectName = "RootUrl"; } else { objectName = NetNamingMapper.GetObjectName(resource.Path); } if (classesNames.Contains(objectName)) { objectName = NetNamingMapper.Capitalize(GetObjectNameForParameter(resource)); } } if (string.IsNullOrWhiteSpace(objectName)) { throw new InvalidOperationException("object name is null for " + resource.Path); } if (!classesNames.Contains(objectName)) { return(objectName); } if (parent == null || string.IsNullOrWhiteSpace(parent.Path)) { return(GetUniqueObjectName(objectName)); } if (resource.Path.StartsWith("/{") && parent.Path.EndsWith("}")) { objectName = NetNamingMapper.Capitalize(GetObjectNameForParameter(parent)) + objectName; } else { objectName = NetNamingMapper.GetObjectName(parent.Path) + objectName; if (classesNames.Contains(objectName)) { objectName = NetNamingMapper.Capitalize(GetObjectNameForParameter(parent)); } } if (string.IsNullOrWhiteSpace(objectName)) { throw new InvalidOperationException("object name is null for " + resource.Path); } if (!classesNames.Contains(objectName)) { return(objectName); } return(GetUniqueObjectName(objectName)); }
public void Scaffold(string ramlSource, RamlChooserActionParams parameters) { var data = parameters.Data; if (data == null || data.RamlDocument == null) { return; } var model = new WebApiGeneratorService(data.RamlDocument, parameters.ControllersNamespace, parameters.ModelsNamespace).BuildModel(); var dte = ServiceProvider.GetService(typeof(SDTE)) as DTE; var proj = VisualStudioAutomationHelper.GetActiveProject(dte); var contractsFolderItem = VisualStudioAutomationHelper.AddFolderIfNotExists(proj, ContractsFolderName); var ramlItem = contractsFolderItem.ProjectItems.Cast <ProjectItem>() .First(i => i.Name.ToLowerInvariant() == parameters.TargetFileName.ToLowerInvariant()); var contractsFolderPath = Path.GetDirectoryName(proj.FullName) + Path.DirectorySeparatorChar + ContractsFolderName + Path.DirectorySeparatorChar; var templates = new[] { ControllerBaseTemplateName, ControllerInterfaceTemplateName, ControllerImplementationTemplateName, ModelTemplateName, EnumTemplateName }; if (!templatesManager.ConfirmWhenIncompatibleServerTemplate(contractsFolderPath, templates)) { return; } var extensionPath = Path.GetDirectoryName(GetType().Assembly.Location) + Path.DirectorySeparatorChar; AddOrUpdateModels(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath); AddOrUpdateEnums(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath); AddOrUpdateControllerBase(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath); AddOrUpdateControllerInterfaces(parameters, contractsFolderPath, ramlItem, model, contractsFolderItem, extensionPath); AddOrUpdateControllerImplementations(parameters, contractsFolderPath, proj, model, contractsFolderItem, extensionPath); AddJsonSchemaParsingErrors(model.Warnings, contractsFolderPath, contractsFolderItem, ramlItem); if (parameters.GenerateUnitTests.HasValue && parameters.GenerateUnitTests.Value) { var testsProj = VisualStudioAutomationHelper.GetProject(dte, parameters.TestsProjectName); parameters.TestsNamespace = VisualStudioAutomationHelper.GetDefaultNamespace(testsProj) + "." + NetNamingMapper.GetObjectName(Path.GetFileNameWithoutExtension(parameters.RamlFilePath)); var unitTestsScaffoldService = UnitTestsScaffoldServiceBase.GetScaffoldService(Microsoft.VisualStudio.Shell.ServiceProvider.GlobalProvider); unitTestsScaffoldService.InstallDependencies(testsProj); unitTestsScaffoldService.ScaffoldToProject(parameters, testsProj); } }