public AzureCSharpFluentCodeNamer(Settings settings) :base(settings) { _innerTypes = new HashSet<CompositeType>(); _resourceType = new CompositeType { Name = "Microsoft.Rest.Azure.Resource", SerializedName = "Resource", }; var stringType = new PrimaryType(KnownPrimaryType.String) { Name = "string" }; _resourceType.Properties.Add(new Property { Name = "location", SerializedName = "location", Type = stringType }); _resourceType.Properties.Add(new Property { Name = "id", SerializedName = "id", Type = stringType }); _resourceType.Properties.Add(new Property { Name = "name", SerializedName = "name", Type = stringType }); _resourceType.Properties.Add(new Property { Name = "type", SerializedName = "type", Type = stringType }); _resourceType.Properties.Add(new Property { Name = "tags", SerializedName = "tags", Type = new DictionaryType { ValueType = stringType, NameFormat = "System.Collections.Generic.IDictionary<string, {0}>" } }); _subResourceType = new CompositeType { Name = "Microsoft.Rest.Azure.SubResource", SerializedName = "SubResource" }; _subResourceType.Properties.Add(new Property { Name = "id", SerializedName = "id", Type = stringType }); }
public void NameCollisionTestWithoutNamespace() { var serviceClient = new ServiceClient(); serviceClient.Name = "azure always rocks!"; var customObjectType = new CompositeType(); customObjectType.Name = "azure always rocks!"; var baseType = new CompositeType(); baseType.Name = "azure always rocks!"; serviceClient.Methods.Add(new Method { Name = "azure always rocks!", Group = "azure always rocks!", ReturnType = new Response(customObjectType, null) }); serviceClient.ModelTypes.Add(customObjectType); serviceClient.ModelTypes.Add(baseType); var framework = new CSharpCodeNamer(); framework.ResolveNameCollisions(serviceClient, null, null); Assert.Equal("azure always rocks!Client", serviceClient.Name); Assert.Equal("azure always rocks!Operations", serviceClient.MethodGroups.First()); Assert.Equal("azure always rocks!", serviceClient.Methods[0].Name); Assert.Equal("azure always rocks!", serviceClient.ModelTypes.First(m => m.Name == "azure always rocks!").Name); }
public ModelTemplateModel(CompositeType source) { this.LoadFrom(source); PropertyTemplateModels = new List<PropertyTemplateModel>(); source.Properties.ForEach(p => PropertyTemplateModels.Add(new PropertyTemplateModel(p))); }
public AzureFluentModelTemplateModel(CompositeType source, ServiceClient serviceClient) : base(source, serviceClient) { _namer = new AzureJavaFluentCodeNamer(serviceClient.Namespace); PropertyModels = new List<PropertyModel>(); Properties.ForEach(p => PropertyModels.Add(new FluentPropertyModel(p, serviceClient.Namespace, IsInnerModel))); }
/// <summary> /// Initializes a new instance of the ModelTemplateModel class. /// </summary> /// <param name="source">The object to create model from.</param> /// <param name="allTypes">The list of all model types; Used to implement polymorphism.</param> public ModelTemplateModel(CompositeType source, ISet<CompositeType> allTypes) { this.LoadFrom(source); PropertyTemplateModels = new List<PropertyTemplateModel>(); source.Properties.ForEach(p => PropertyTemplateModels.Add(new PropertyTemplateModel(p))); if (!string.IsNullOrEmpty(source.PolymorphicDiscriminator)) { if (!source.Properties.Any(p => p.Name == source.PolymorphicDiscriminator)) { var polymorphicProperty = new Property { IsRequired = true, Name = source.PolymorphicDiscriminator, SerializedName = source.PolymorphicDiscriminator, Documentation = "Polymorhpic Discriminator", Type = new PrimaryType(KnownPrimaryType.String) }; source.Properties.Add(polymorphicProperty); } } if (source.BaseModelType != null) { this.parent = new ModelTemplateModel(source.BaseModelType, allTypes); } this.allTypes = allTypes; }
public ModelTemplateModel(CompositeType source, ServiceClient serviceClient) { this.LoadFrom(source); ServiceClient = serviceClient; if (source.BaseModelType != null) { _parent = new ModelTemplateModel(source.BaseModelType, serviceClient); } }
public ModelTemplateModel(CompositeType source) { this.LoadFrom(source); PropertyTemplateModels = new List<PropertyTemplateModel>(); source.Properties.ForEach(p => PropertyTemplateModels.Add(new PropertyTemplateModel(p))); if (source.BaseModelType != null) { this._baseModel = new ModelTemplateModel(source.BaseModelType); } this._constructorModel = new ConstructorModel(this); }
public ModelTemplateModel(CompositeType source, ServiceClient serviceClient) { this.LoadFrom(source); ServiceClient = serviceClient; if(source.BaseModelType != null) { _parent = new ModelTemplateModel(source.BaseModelType, serviceClient); } _namer = new JavaCodeNamer(serviceClient.Namespace); PropertyModels = new List<PropertyModel>(); Properties.ForEach(p => PropertyModels.Add(new PropertyModel(p, serviceClient.Namespace))); }
public void ParseWithServiceClientWithCreateResourceMethod() { ServiceClient serviceClient = new ServiceClient(); serviceClient.ApiVersion = "2016-01-01"; Parameter body = new Parameter() { Location = ParameterLocation.Body, Type = new CompositeType(), }; CompositeType responseBody = new CompositeType(); responseBody.Extensions.Add("x-ms-azure-resource", true); const string url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Mock.Provider/mockResourceNames/{mockResourceName}"; Method method = new Method() { HttpMethod = HttpMethod.Put, ReturnType = new Response(responseBody, null), Url = url, }; method.Parameters.Add(body); serviceClient.Methods.Add(method); IDictionary<string, ResourceSchema> schemas = ResourceSchemaParser.Parse(serviceClient); Assert.NotNull(schemas); Assert.Equal(1, schemas.Count); ResourceSchema schema = schemas["Mock.Provider"]; Assert.Equal("http://schema.management.azure.com/schemas/2016-01-01/Mock.Provider.json#", schema.Id); Assert.Equal("http://json-schema.org/draft-04/schema#", schema.Schema); Assert.Equal("Mock.Provider", schema.Title); Assert.Equal("Mock Provider Resource Types", schema.Description); Assert.Equal(1, schema.ResourceDefinitions.Count); Assert.Equal("mockResourceNames", schema.ResourceDefinitions.Keys.Single()); Assert.Equal( new JsonSchema() { JsonType = "object", Description = "Mock.Provider/mockResourceNames" } .AddProperty("type", JsonSchema.CreateStringEnum("Mock.Provider/mockResourceNames"), true) .AddProperty("apiVersion", JsonSchema.CreateStringEnum("2016-01-01"), true), schema.ResourceDefinitions["mockResourceNames"]); Assert.NotNull(schema.Definitions); Assert.Equal(0, schema.Definitions.Count); }
public ModelTemplateModel(CompositeType source, ServiceClient serviceClient) { if (!string.IsNullOrEmpty(source.PolymorphicDiscriminator)) { if (!source.Properties.Any(p => p.Name == source.PolymorphicDiscriminator)) { var polymorphicProperty = new Property { IsRequired = true, Name = source.PolymorphicDiscriminator, SerializedName = source.PolymorphicDiscriminator, Documentation = "Polymorhpic Discriminator", Type = new PrimaryType(KnownPrimaryType.String) }; source.Properties.Add(polymorphicProperty); } } this.LoadFrom(source); ServiceClient = serviceClient; if (source.BaseModelType != null) { _parent = new ModelTemplateModel(source.BaseModelType, serviceClient); } }
public void VerifyInputMappingsForFlattening() { var serviceClient = new ServiceClient(); serviceClient.Name = "test service client"; var customObjectType = new CompositeType(); customObjectType.Name = "Foo"; customObjectType.Properties.Add(new Property { Name = "A", Type = new PrimaryType(KnownPrimaryType.Boolean) }); customObjectType.Properties.Add(new Property { Name = "B", Type = new PrimaryType(KnownPrimaryType.String) }); var method = new Method { Name = "method1", Group = "mGroup", ReturnType = new Response(customObjectType, null) }; var outputParameter = new Parameter { Name = "body", Type = customObjectType }; serviceClient.Methods.Add(method); method.Parameters.Add(new Parameter { Name = "paramA", Type = new PrimaryType(KnownPrimaryType.Boolean), SerializedName = "paramA" }); method.Parameters.Add(new Parameter { Name = "paramB", Type = new PrimaryType(KnownPrimaryType.String), SerializedName = "paramB" }); method.InputParameterTransformation.Add(new ParameterTransformation { OutputParameter = outputParameter }); method.InputParameterTransformation[0].ParameterMappings.Add(new ParameterMapping { InputParameter = method.Parameters[0], OutputParameterProperty = "A" }); method.InputParameterTransformation[0].ParameterMappings.Add(new ParameterMapping { InputParameter = method.Parameters[1], OutputParameterProperty = "B" }); MethodTemplateModel templateModel = new MethodTemplateModel(method, serviceClient,SyncMethodsGenerationMode.All); var output = templateModel.BuildInputMappings(); System.Console.WriteLine(output); string expected = @"Foo body = default(Foo); if (paramA != null || paramB != null) { body = new Foo(); body.A = paramA; body.B = paramB; }"; MultilineAreEqual(expected, output.Trim()); }
public FluentCompositeTypeModel(CompositeType compositeType, string package) : base(compositeType, package) { this.LoadFrom(compositeType); }
public static IndentedStringBuilder ConstructPolymorphicDiscriminator(CompositeType composite, IndentedStringBuilder builder) { if (composite == null) { throw new ArgumentNullException("composite"); } if (builder == null) { throw new ArgumentNullException("builder"); } // Note: If the polymorphicDiscriminator has a dot in it's name then do not escape that dot for // it's serializedName, the way it is done for other properties. This makes it easy to find the // discriminator property from the responseBody during deserialization. Please, do not get confused // between the definition of the discriminator and the definition of the property that is // marked as the discriminator. builder.AppendLine("polymorphicDiscriminator: {") .Indent() .AppendLine("serializedName: '{0}',", composite.PolymorphicDiscriminator) .AppendLine("clientName: '{0}'", new NodeJsCodeNamer().GetPropertyName(composite.PolymorphicDiscriminator)) .Outdent() .AppendLine("},"); var polymorphicType = composite; while (polymorphicType.BaseModelType != null) { polymorphicType = polymorphicType.BaseModelType; } builder.AppendLine("uberParent: '{0}',", polymorphicType.Name); return builder; }
private string GetPagingSetting(CompositeType body, Dictionary<string, object> extensions, string valueTypeName, IDictionary<int, string> typePageClasses, String methodName) { var ext = extensions[AzureExtensions.PageableExtension] as Newtonsoft.Json.Linq.JContainer; bool ignoreNextLink = false; if (ext["nextLinkName"] != null && ext["nextLinkName"].Type == Newtonsoft.Json.Linq.JTokenType.Null) { ignoreNextLink = true; } string nextLinkName = (string)ext["nextLinkName"] ?? "nextLink"; string itemName = (string)ext["itemName"] ?? "value"; nextLinkName = nextLinkName.Replace(".", "\\\\."); itemName = itemName.Replace(".", "\\\\."); bool findNextLink = false; bool findItem = false; foreach (var property in body.ComposedProperties) { if (property.SerializedName == nextLinkName) { findNextLink = true; } else if (property.SerializedName == itemName) { findItem = true; } } if (!ignoreNextLink && !findNextLink) { throw new KeyNotFoundException(String.Format(CultureInfo.InvariantCulture, "Couldn't find the nextLink property specified by extension on operation {0} and property {1}", methodName, body.SerializedName)); } if (!findItem) { throw new KeyNotFoundException("Couldn't find the item property specified by extension"); } string className; var hash = (nextLinkName + "#" + itemName).GetHashCode(); if (!typePageClasses.ContainsKey(hash)) { className = (string)ext["className"]; if (string.IsNullOrEmpty(className)) { if (typePageClasses.Count > 0) { className = valueTypeName + String.Format(CultureInfo.InvariantCulture, "Paged{0}", typePageClasses.Count); } else { className = valueTypeName + "Paged"; } } typePageClasses.Add(hash, className); } className = typePageClasses[hash]; ext["className"] = className; var pageModel = new PageTemplateModel(className, nextLinkName, itemName, valueTypeName); if (!pageModels.Contains(pageModel)) { pageModels.Add(pageModel); } return className; }
public AzureModelTemplateModel(CompositeType source, ServiceClient serviceClient) : base(source, serviceClient) { _namer = new AzureJavaCodeNamer(serviceClient.Namespace); }
public CompositeTypeModel(CompositeType compositeType, string package) : this(package) { this.LoadFrom(compositeType); }
/// <summary> /// Changes paginated method signatures to return Page type. /// </summary> /// <param name="serviceClient"></param> private void NormalizePaginatedMethods(ServiceClient serviceClient) { if (serviceClient == null) { throw new ArgumentNullException("serviceClient"); } var convertedTypes = new Dictionary<IType, Response>(); foreach (var method in serviceClient.Methods.Where(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension))) { foreach (var responseStatus in method.Responses.Where(r => r.Value.Body is CompositeType).Select(s => s.Key)) { var compositType = (CompositeType)method.Responses[responseStatus].Body; var sequenceType = compositType.Properties.Select(p => p.Type).FirstOrDefault(t => t is SequenceType) as SequenceType; // if the type is a wrapper over page-able response if (sequenceType != null) { string valueType = sequenceType.ElementType.Name; if (!pageClasses.ContainsKey(valueType)) { pageClasses.Add(valueType, new Dictionary<int, string>()); } string pagableTypeName = GetPagingSetting(compositType, method.Extensions, valueType, pageClasses[valueType], method.SerializedName); CompositeType pagedResult = new CompositeType { Name = pagableTypeName }; convertedTypes[compositType] = new Response(pagedResult, null); method.Responses[responseStatus] = convertedTypes[compositType]; break; } } if (convertedTypes.ContainsKey(method.ReturnType.Body)) { method.ReturnType = convertedTypes[method.ReturnType.Body]; } } SwaggerExtensions.RemoveUnreferencedTypes(serviceClient, new HashSet<string>(convertedTypes.Keys.Cast<CompositeType>().Select(t => t.Name))); }
public void SequenceWithRenamedComplexType() { var serviceClient = new ServiceClient(); serviceClient.Name = "azure always rocks!"; var complexType = new CompositeType(); complexType.Name = "Greetings"; serviceClient.Methods.Add(new Method { Name = "List", ReturnType = new Response(new SequenceType { ElementType = complexType }, null) }); serviceClient.Methods.Add(new Method { Name = "List2", ReturnType = new Response(new DictionaryType { ValueType = complexType }, null) }); serviceClient.ModelTypes.Add(complexType); var codeGenerator = new CSharpCodeGenerator(new Settings { Namespace = "Polar.Greetings" }); codeGenerator.NormalizeClientModel(serviceClient); Assert.Equal("GreetingsModel", complexType.Name); Assert.Equal("System.Collections.Generic.IList<GreetingsModel>", serviceClient.Methods[0].ReturnType.Body.Name); Assert.Equal("System.Collections.Generic.IDictionary<string, GreetingsModel>", serviceClient.Methods[1].ReturnType.Body.Name); }
public PageTemplateModel(CompositeType source, ServiceClient serviceClient, string nextLinkName, string itemName) : base(source, serviceClient) { this.NextLinkName = nextLinkName; this.ItemName = itemName; }
protected virtual IType NormalizeCompositeType(CompositeType compositeType) { compositeType.Name = GetTypeName(compositeType.Name); foreach (var property in compositeType.Properties) { property.Name = GetPropertyName(property.GetClientName()); property.Type = NormalizeTypeReference(property.Type); if (!property.IsRequired) { property.Type = WrapPrimitiveType(property.Type); } } if (compositeType.BaseModelType != null) { compositeType.BaseModelType = (CompositeType) NormalizeTypeReference(compositeType.BaseModelType); } return compositeType; }
protected virtual CompositeTypeModel NewCompositeTypeModel(CompositeType compositeType) { return new CompositeTypeModel(compositeType, _package); }
private void BuildOptionsParameterTemplateModel() { CompositeType optionsType; optionsType = new CompositeType { Name = "options", SerializedName = "options", Documentation = "Optional Parameters." }; var optionsParmeter = new Parameter { Name = "options", SerializedName = "options", IsRequired = false, Documentation = "Optional Parameters.", Location = ParameterLocation.None, Type = optionsType }; IEnumerable<ParameterTemplateModel> optionalParameters = LocalParameters.Where(p => !p.IsRequired); foreach (ParameterTemplateModel parameter in optionalParameters) { Property optionalProperty = new Property { IsReadOnly = false, Name = parameter.Name, IsRequired = parameter.IsRequired, DefaultValue = parameter.DefaultValue, Documentation = parameter.Documentation, Type = parameter.Type, SerializedName = parameter.SerializedName }; parameter.Constraints.ToList().ForEach(x => optionalProperty.Constraints.Add(x.Key, x.Value)); parameter.Extensions.ToList().ForEach(x => optionalProperty.Extensions.Add(x.Key, x.Value)); ((CompositeType)optionsParmeter.Type).Properties.Add(optionalProperty); } //Adding customHeaders to the options object Property customHeaders = new Property { IsReadOnly = false, Name = "customHeaders", IsRequired = false, Documentation = "Headers that will be added to the request", Type = new PrimaryType(KnownPrimaryType.Object), SerializedName = "customHeaders" }; ((CompositeType)optionsParmeter.Type).Properties.Add(customHeaders); OptionsParameterTemplateModel = new ParameterTemplateModel(optionsParmeter); }
/// <summary> /// Normalizes composite type. /// </summary> /// <param name="compositeType">Type to normalize.</param> /// <returns>Normalized type.</returns> private IType NormalizeCompositeType(CompositeType compositeType) { compositeType.Name = GetTypeName(compositeType.Name); foreach (var property in compositeType.Properties) { property.Name = GetPropertyName(property.GetClientName()); if (property.SerializedName != null && !property.WasFlattened()) { property.SerializedName = property.SerializedName.Replace(".", "\\\\."); } property.Type = NormalizeTypeReference(property.Type); } return compositeType; }
public void TypeNormalizationWithComplexTypesTest() { var serviceClient = new ServiceClient(); serviceClient.Name = "azure always rocks!"; var childObject = new CompositeType(); childObject.Name = "child"; childObject.Properties.Add(new Property { Name = "childProperty", Type = new PrimaryType(KnownPrimaryType.String) }); var customObjectType = new CompositeType(); customObjectType.Name = "sample"; customObjectType.Properties.Add(new Property { Name = "child", Type = childObject }); customObjectType.Properties.Add(new Property { Name = "childList", Type = new SequenceType { ElementType = childObject } }); customObjectType.Properties.Add(new Property { Name = "childDict", Type = new DictionaryType { ValueType = childObject } }); serviceClient.ModelTypes.Add(customObjectType); serviceClient.ModelTypes.Add(childObject); var framework = new CSharpCodeNamer(); framework.NormalizeClientModel(serviceClient); framework.ResolveNameCollisions(serviceClient, "SampleNs", "SampleNs.Models"); Assert.Equal("Sample", serviceClient.ModelTypes.First(m => m.Name == "Sample").Name); Assert.Equal("Child", serviceClient.ModelTypes.First(m => m.Name == "Sample").Properties[0].Name); Assert.Equal("Child", serviceClient.ModelTypes.First(m => m.Name == "Sample").Properties[0].Type.Name); Assert.Equal("ChildList", serviceClient.ModelTypes.First(m => m.Name == "Sample").Properties[1].Name); Assert.Equal("System.Collections.Generic.IList<Child>", serviceClient.ModelTypes.First(m => m.Name == "Sample").Properties[1].Type.Name); Assert.Equal("ChildDict", serviceClient.ModelTypes.First(m => m.Name == "Sample").Properties[2].Name); Assert.Equal("System.Collections.Generic.IDictionary<string, Child>", serviceClient.ModelTypes.First(m => m.Name == "Sample").Properties[2].Type.Name); Assert.Equal("Child", serviceClient.ModelTypes.First(m => m.Name == "Child").Name); Assert.Equal("string", serviceClient.ModelTypes.First(m => m.Name == "Child").Properties[0].Type.Name); }
public void TypeNormalizationTest() { var serviceClient = new ServiceClient(); serviceClient.Name = "azure always rocks!"; serviceClient.Properties.Add(new Property { Name = "&%$ i rock too!", Type = new PrimaryType(KnownPrimaryType.Int) }); serviceClient.Properties.Add(new Property { Name = "some-other-stream", Type = new PrimaryType(KnownPrimaryType.Stream) }); var customObjectType = new CompositeType(); customObjectType.Name = "!@#$%^&*()abc"; customObjectType.SerializedName = "!@#$%^&*()abc"; customObjectType.Properties.Add(new Property { Name = "boolean-property", Type = new PrimaryType(KnownPrimaryType.Boolean) }); customObjectType.Properties.Add(new Property { Name = "some^dateTime_sequence", Type = new SequenceType { ElementType = new PrimaryType(KnownPrimaryType.DateTime) } }); var baseType = new CompositeType(); baseType.Name = "baseType"; baseType.SerializedName = "baseType"; baseType.Properties.Add(new Property { Name = "boolean-property", SerializedName = "boolean-property", Type = new PrimaryType(KnownPrimaryType.Boolean) }); baseType.BaseModelType = baseType; baseType.Properties.Add(new Property { Name = "self-property", SerializedName = "self-property", Type = baseType }); customObjectType.BaseModelType = baseType; serviceClient.ModelTypes.Add(customObjectType); serviceClient.ModelTypes.Add(baseType); var framework = new CSharpCodeNamer(); framework.NormalizeClientModel(serviceClient); Assert.Equal("Azurealwaysrocks", serviceClient.Name); Assert.Equal("Abc", serviceClient.ModelTypes.First(m => m.Name == "Abc").Name); Assert.Equal("!@#$%^&*()abc", serviceClient.ModelTypes.First(m => m.Name == "Abc").SerializedName); Assert.Equal("BooleanProperty", serviceClient.ModelTypes.First(m => m.Name == "Abc").Properties[0].Name); Assert.Equal("SomedateTimeSequence", serviceClient.ModelTypes.First(m => m.Name == "Abc").Properties[1].Name); Assert.Equal("BaseType", serviceClient.ModelTypes.First(m => m.Name == "BaseType").Name); Assert.Equal("baseType", serviceClient.ModelTypes.First(m => m.Name == "BaseType").SerializedName); Assert.Equal("BooleanProperty", serviceClient.ModelTypes.First(m => m.Name == "BaseType").Properties[0].Name); Assert.Equal("boolean-property", serviceClient.ModelTypes.First(m => m.Name == "BaseType").Properties[0].SerializedName); Assert.Equal("SelfProperty", serviceClient.ModelTypes.First(m => m.Name == "BaseType").Properties[1].Name); Assert.Equal("self-property", serviceClient.ModelTypes.First(m => m.Name == "BaseType").Properties[1].SerializedName); }
private IType NormalizeCompositeType(CompositeType compositeType) { // Composite types normalize to the same object _normalizedTypes[compositeType] = compositeType; compositeType.Name = GetTypeName(compositeType.Name); foreach (var property in compositeType.Properties) { property.SerializedName = property.Name; property.Name = GetPropertyName(property.Name); // gosdk: For now, inherit Enumerated type names from the composite type field name if (property.Type is EnumType) { var enumType = property.Type as EnumType; if (String.IsNullOrEmpty(enumType.Name)) { enumType.Name = property.Name; } } property.Type = NormalizeTypeReference(property.Type); } return compositeType; }
protected override CompositeTypeModel NewCompositeTypeModel(CompositeType compositeType) { return new AzureCompositeTypeModel(compositeType, _package); }
public void VerifyInputMappingsForResources() { var serviceClient = new ServiceClient(); serviceClient.Name = "test service client"; var flattenedPropertyType = new CompositeType(); flattenedPropertyType.Name = "FooFlattened"; flattenedPropertyType.Properties.Add(new Property { Name = "Sku", Type = new PrimaryType(KnownPrimaryType.String) }); flattenedPropertyType.Properties.Add(new Property { Name = "ProvState", Type = new PrimaryType(KnownPrimaryType.String) }); flattenedPropertyType.Properties.Add(new Property { Name = "Id", Type = new PrimaryType(KnownPrimaryType.Int) }); var customObjectPropertyType = new CompositeType(); customObjectPropertyType.Name = "FooProperty"; customObjectPropertyType.Properties.Add(new Property { Name = "Sku", Type = new PrimaryType(KnownPrimaryType.String) }); customObjectPropertyType.Properties.Add(new Property { Name = "ProvState", Type = new PrimaryType(KnownPrimaryType.String) }); var customObjectType = new CompositeType(); customObjectType.Name = "Foo"; customObjectType.Properties.Add(new Property { Name = "Property", Type = customObjectPropertyType }); customObjectType.Properties.Add(new Property { Name = "Id", Type = new PrimaryType(KnownPrimaryType.Int) }); var method = new Method { Name = "method1", Group = "mGroup", ReturnType = new Response(flattenedPropertyType, null) }; var inputParameter = new Parameter { Name = "prop", Type = flattenedPropertyType }; serviceClient.Methods.Add(method); method.Parameters.Add(inputParameter); method.InputParameterTransformation.Add(new ParameterTransformation { OutputParameter = new Parameter { Name = "body", Type = customObjectType, SerializedName = "body" } }); method.InputParameterTransformation.Last().ParameterMappings.Add(new ParameterMapping { InputParameter = inputParameter, InputParameterProperty = "Id", OutputParameterProperty = "Id" }); method.InputParameterTransformation.Last().ParameterMappings.Add(new ParameterMapping { InputParameter = inputParameter, InputParameterProperty = "Sku", OutputParameterProperty = "Property.Sku" }); method.InputParameterTransformation.Last().ParameterMappings.Add(new ParameterMapping { InputParameter = inputParameter, InputParameterProperty = "ProvState", OutputParameterProperty = "Property.ProvState" }); MethodTemplateModel templateModel = new MethodTemplateModel(method, serviceClient,SyncMethodsGenerationMode.All); var output = templateModel.BuildInputMappings(); string expected = @"String paramA = null; if (body != null) { paramA = body.A; } String paramB = default(String); if (body != null) { paramB = body.B; }"; MultilineAreEqual(expected, output.Trim()); }
private static JsonSchema ParseCompositeType(Property property, CompositeType compositeType, IDictionary<string, JsonSchema> definitions, IEnumerable<CompositeType> modelTypes) { string definitionName = compositeType.Name; if (!definitions.ContainsKey(definitionName)) { JsonSchema definition = new JsonSchema() { JsonType = "object", Description = compositeType.Documentation }; // This definition must be added to the definition map before we start parsing // its properties because its properties may recursively reference back to this // definition. definitions.Add(definitionName, definition); foreach (Property subProperty in compositeType.ComposedProperties) { JsonSchema subPropertyDefinition = ParseType(subProperty, subProperty.Type, definitions, modelTypes); if (subPropertyDefinition != null) { definition.AddProperty(subProperty.Name, subPropertyDefinition, subProperty.IsRequired); } } string discriminatorPropertyName = compositeType.PolymorphicDiscriminator; if (!string.IsNullOrWhiteSpace(discriminatorPropertyName)) { CompositeType[] subTypes = modelTypes.Where(modelType => modelType.BaseModelType == compositeType).ToArray(); if (subTypes != null && subTypes.Length > 0) { JsonSchema discriminatorDefinition = new JsonSchema() { JsonType = "string" }; if (subTypes.Length == 1) { CompositeType subType = subTypes[0]; if (subType != null) { foreach (Property subTypeProperty in subType.Properties) { JsonSchema subTypePropertyDefinition = ParseType(subTypeProperty, subTypeProperty.Type, definitions, modelTypes); if (subTypePropertyDefinition != null) { definition.AddProperty(subTypeProperty.Name, subTypePropertyDefinition, subTypeProperty.IsRequired); } } const string discriminatorValueExtensionName = "x-ms-discriminator-value"; if (subType.ComposedExtensions.ContainsKey(discriminatorValueExtensionName)) { string discriminatorValue = subType.ComposedExtensions[discriminatorValueExtensionName] as string; if (!string.IsNullOrWhiteSpace(discriminatorValue)) { discriminatorDefinition.AddEnum(discriminatorValue); } } } definition.AddProperty(discriminatorPropertyName, discriminatorDefinition); } else { string errorMessage = string.Format( CultureInfo.CurrentCulture, "Multiple sub-types ({0}) of a polymorphic discriminated type ({1}) are not currently supported.", string.Join(", ", subTypes.Select(subType => subType.Name)), compositeType.Name); throw new NotSupportedException(errorMessage); } } } } JsonSchema result = new JsonSchema() { Ref = "#/definitions/" + definitionName }; if (property != null) { result.Description = RemovePossibleValuesFromDescription(property.Documentation); } return result; }
public void VerifyMethodRenaming() { var serviceClient = new ServiceClient(); serviceClient.Name = "azure always rocks!"; var customObjectType = new CompositeType(); customObjectType.Name = "!@#$%^&*()abc"; customObjectType.Properties.Add(new Property { Name = "boolean-property", Type = new PrimaryType(KnownPrimaryType.Boolean) }); serviceClient.Methods.Add(new Method { Name = " method name with lots of spaces", Group = "#$% group with lots of-weird-characters", ReturnType = new Response(customObjectType, null) }); var framework = new CSharpCodeNamer(); framework.NormalizeClientModel(serviceClient); Assert.Equal("Methodnamewithlotsofspaces", serviceClient.Methods[0].Name); Assert.Equal("GroupwithlotsofWeirdCharacters", serviceClient.Methods[0].Group); Assert.Equal("Abc", serviceClient.Methods[0].ReturnType.Body.Name); }