コード例 #1
0
        public void ResourceIsFlattenedForConflictingResource()
        {
            var serviceClient = new ServiceClient();
            serviceClient.BaseUrl = "https://petstore.swagger.wordnik.com";
            serviceClient.ApiVersion = "1.0.0";
            serviceClient.Documentation =
                "A sample API that uses a petstore as an example to demonstrate features in the swagger-2.0 specification";
            serviceClient.Name = "Swagger Petstore";

            var getPet = new Method();
            var resource = new CompositeType();
            var dogProperties = new CompositeType();
            var dog = new CompositeType();
            serviceClient.Methods.Add(getPet);
            resource.Name = "resource";
            resource.Properties.Add(new Property
            {
                Name = "id",
                SerializedName = "id",
                Type = new PrimaryType(KnownPrimaryType.String),
                IsRequired = true
            });
            resource.Properties.Add(new Property
            {
                Name = "location",
                SerializedName = "location",
                Type = new PrimaryType(KnownPrimaryType.String),
                IsRequired = true
            });
            resource.Properties.Add(new Property
            {
                Name = "name",
                SerializedName = "name",
                Type = new PrimaryType(KnownPrimaryType.String),
                IsRequired = true
            });
            resource.Properties.Add(new Property
            {
                Name = "tags",
                SerializedName = "tags",
                Type = new SequenceType { ElementType = new PrimaryType(KnownPrimaryType.String) },
                IsRequired = true
            });
            resource.Properties.Add(new Property
            {
                Name = "type",
                SerializedName = "type",
                Type = new PrimaryType(KnownPrimaryType.String),
                IsRequired = true
            });
            dogProperties.Name = "dogProperties";
            dogProperties.SerializedName = "dogProperties";
            dogProperties.Properties.Add(new Property
            {
                Name = "id",
                SerializedName = "id",
                Type = new PrimaryType(KnownPrimaryType.Long),
                IsRequired = true
            });
            dogProperties.Properties.Add(new Property
            {
                Name = "name",
                SerializedName = "name",
                Type = new PrimaryType(KnownPrimaryType.String),
                IsRequired = true
            });
            dog.Name = "dog";
            dog.SerializedName = "dog";
            dog.BaseModelType = resource;
            var dogPropertiesProperty = new Property
            {
                Name = "properties",
                SerializedName = "properties",
                Type = dogProperties,
                IsRequired = true
            };
            dogPropertiesProperty.Extensions[Generator.Extensions.FlattenExtension] = true;
            dog.Properties.Add(dogPropertiesProperty);
            dog.Properties.Add(new Property
            {
                Name = "pedigree",
                SerializedName = "pedigree",
                Type = new PrimaryType(KnownPrimaryType.Boolean),
                IsRequired = true
            });
            getPet.ReturnType = new Response(dog, null);

            serviceClient.ModelTypes.Add(resource);
            serviceClient.ModelTypes.Add(dogProperties);
            serviceClient.ModelTypes.Add(dog);

            var codeGen = new SampleAzureCodeGenerator(new Settings());
            codeGen.NormalizeClientModel(serviceClient);
            Assert.Equal(3, serviceClient.ModelTypes.Count);
            Assert.Equal("dog", serviceClient.ModelTypes.First(m => m.Name == "dog").Name);
            Assert.Equal(3, serviceClient.ModelTypes.First(m => m.Name == "dog").Properties.Count);
            Assert.True(serviceClient.ModelTypes.First(m => m.Name == "dog").Properties.Any(p => p.Name == "dog_name"));
            Assert.True(serviceClient.ModelTypes.First(m => m.Name == "dog").Properties.Any(p => p.Name == "dog_id"));
            Assert.True(serviceClient.ModelTypes.First(m => m.Name == "dog").Properties.Any(p => p.Name == "pedigree"));
            Assert.Equal("dog", serviceClient.Methods[0].ReturnType.Body.Name);
            Assert.Equal(serviceClient.ModelTypes.First(m => m.Name == "dog"), serviceClient.Methods[0].ReturnType.Body);
        }
コード例 #2
0
        public override IType BuildServiceType(string serviceTypeName)
        {
            // Check if already generated
            if (serviceTypeName != null && Modeler.GeneratedTypes.ContainsKey(serviceTypeName))
            {
                return Modeler.GeneratedTypes[serviceTypeName];
            }

            _schema = Modeler.Resolver.Unwrap(_schema);

            // If primitive type
            if ((_schema.Type != null && _schema.Type != DataType.Object) ||
                _schema.AdditionalProperties != null)
            {
                return _schema.GetBuilder(Modeler).ParentBuildServiceType(serviceTypeName);
            }

            // If the object does not have any properties, treat it as raw json (i.e. object)
            if (_schema.Properties.IsNullOrEmpty() && string.IsNullOrEmpty(_schema.Extends))
            {
                return PrimaryType.Object;
            }

            // Otherwise create new object type
            var objectType = new CompositeType 
                            { 
                                Name = serviceTypeName, 
                                SerializedName = serviceTypeName, 
                                Documentation = _schema.Description 
                            };
            // Put this in already generated types serializationProperty
            Modeler.GeneratedTypes[serviceTypeName] = objectType;

            if (_schema.Properties != null)
            {
                // Visit each property and recursively build service types
                foreach (var property in _schema.Properties)
                {
                    string name = property.Key;
                    if (name != _schema.Discriminator)
                    {
                        string propertyServiceTypeName;
                        if (property.Value.Reference != null)
                        {
                            propertyServiceTypeName = property.Value.Reference.StripDefinitionPath();
                        }
                        else
                        {
                            propertyServiceTypeName = serviceTypeName + "_" + property.Key;
                        }
                        var propertyType =
                            property.Value.GetBuilder(Modeler).BuildServiceType(propertyServiceTypeName);

                        var propertyObj = new Property
                        {
                            Name = name,
                            SerializedName = name,
                            Type = propertyType,
                            IsRequired = property.Value.IsRequired
                        };

                        //propertyObj.Type = objectType;
                        propertyObj.Documentation = property.Value.Description;
                        var enumType = propertyType as EnumType;
                        if (enumType != null)
                        {
                            if (propertyObj.Documentation == null)
                            {
                                propertyObj.Documentation = string.Empty;
                            }
                            else
                            {
                                propertyObj.Documentation = propertyObj.Documentation.TrimEnd('.') + ". ";
                            }
                            propertyObj.Documentation += "Possible values for this property include: " +
                                                       string.Join(", ", enumType.Values.Select(v =>
                                                           string.Format(CultureInfo.InvariantCulture, 
                                                           "'{0}'", v.Name))) + ".";
                        }
                        propertyObj.IsReadOnly = property.Value.ReadOnly;
                        objectType.Properties.Add(propertyObj);
                    }
                    else
                    {
                        objectType.PolymorphicDiscriminator = name;
                    }
                }
            }

            // Copy over extensions
            _schema.Extensions.ForEach(e => objectType.Extensions[e.Key] = e.Value);

            // Put this in the extended type serializationProperty for building method return type in the end
            if (_schema.Extends != null)
            {
                Modeler.ExtendedTypes[serviceTypeName] = _schema.Extends.StripDefinitionPath();
            }

            return objectType;
        }
コード例 #3
0
 /// <summary>
 /// Initializes a new instance of the class PropertyTemplateModel.
 /// </summary>
 /// <param name="source">The source property object.</param>
 public PropertyTemplateModel(Property source)
 {
     this.LoadFrom(source);
 }