public override CodeModelPy TransformCodeModel(CodeModel cm)
        {
            var codeModel = cm as CodeModelPy;

            // Put the initial namespace value, not transformed by the Core
            // Note that the "Else" is not supposed to be used, since Autorest
            // provides a default value now for Namespace, so Namespace is never empty.
            codeModel.Namespace = Settings.Instance.Namespace.Else(codeModel.Name.ToPythonCase().ToLower());

            // api_version is no longer a parameter of the constructor
            codeModel.Remove(codeModel.Properties.FirstOrDefault(p => p.Name == "api_version"));

            // If one of the constructor parameter is called base_url, rename it to base_url_parameter
            Property baseUrlPRop = codeModel.Properties.FirstOrDefault(each => each.Name == "base_url");

            if (baseUrlPRop != null)
            {
                baseUrlPRop.Name = "base_url_parameter";
            }

            TransformGroupApiVersionToLocal(codeModel);
            SwaggerExtensions.NormalizeClientModel(codeModel);
            PopulateAdditionalProperties(codeModel);
            PopulateDiscriminator(codeModel);
            Flattening(codeModel);
            GenerateConstantProperties(codeModel);
            return(codeModel);
        }
        public void TestParameterLocationExtension()
        {
            using (NewContext)
            {
                var setting = new Settings
                {
                    Namespace = "Test",
                    Input     = Path.Combine("Swagger", "swagger-parameter-location.json"),
                    PayloadFlatteningThreshold = 3
                };
                var modeler     = new SwaggerModeler();
                var clientModel = modeler.Build();
                SwaggerExtensions.NormalizeClientModel(clientModel);

                Assert.NotNull(clientModel);
                Assert.Equal(2, clientModel.Properties.Count);
                Assert.Equal(clientModel.Properties[0].Name, "SubscriptionId");
                Assert.Equal(clientModel.Properties[1].Name, "ApiVersion");
                Assert.False(
                    clientModel.Methods[0].Parameters.First(p => p.Name == "resourceGroupName").IsClientProperty);
                Assert.True(clientModel.Methods[0].Parameters.First(p => p.Name == "subscriptionId").IsClientProperty);
                Assert.True(clientModel.Methods[0].Parameters.First(p => p.Name == "apiVersion").IsClientProperty);
                Assert.False(
                    clientModel.Methods[1].Parameters.First(p => p.Name == "resourceGroupName").IsClientProperty);
                Assert.True(clientModel.Methods[1].Parameters.First(p => p.Name == "subscriptionId").IsClientProperty);
                Assert.True(clientModel.Methods[1].Parameters.First(p => p.Name == "apiVersion").IsClientProperty);
            }
        }
        public void TestClientModelWithPayloadFlattening()
        {
            using (NewContext)
            {
                var setting = new Settings
                {
                    Namespace = "Test",
                    Input     = Path.Combine("Swagger", "swagger-payload-flatten.json"),
                    PayloadFlatteningThreshold = 3
                };
                var modeler     = new SwaggerModeler();
                var clientModel = modeler.Build();
                SwaggerExtensions.NormalizeClientModel(clientModel);

                Assert.NotNull(clientModel);
                Assert.Equal(4, clientModel.Methods[0].Parameters.Count);
                Assert.Equal("String subscriptionId", clientModel.Methods[0].Parameters[0].ToString());
                Assert.Equal("String resourceGroupName", clientModel.Methods[0].Parameters[1].ToString());
                Assert.Equal("String apiVersion", clientModel.Methods[0].Parameters[2].ToString());
                Assert.Equal("MaxProduct maxProduct", clientModel.Methods[0].Parameters[3].ToString());
                Assert.Equal(6, clientModel.Methods[1].Parameters.Count);
                Assert.Equal("String subscriptionId", clientModel.Methods[1].Parameters[0].ToString());
                Assert.Equal("String resourceGroupName", clientModel.Methods[1].Parameters[1].ToString());
                Assert.Equal("String apiVersion", clientModel.Methods[1].Parameters[2].ToString());
                Assert.Equal("String baseProductId", clientModel.Methods[1].Parameters[3].ToString());
                Assert.Equal(true, clientModel.Methods[1].Parameters[3].IsRequired);
                Assert.Equal("String baseProductDescription", clientModel.Methods[1].Parameters[4].ToString());
                Assert.Equal(false, clientModel.Methods[1].Parameters[4].IsRequired);
                Assert.Equal("MaxProduct maxProductReference", clientModel.Methods[1].Parameters[5].ToString());
                Assert.Equal(false, clientModel.Methods[1].Parameters[5].IsRequired);
                Assert.Equal(1, clientModel.Methods[1].InputParameterTransformation.Count);
                Assert.Equal(3, clientModel.Methods[1].InputParameterTransformation[0].ParameterMappings.Count);
            }
        }
        public override CodeModelTS TransformCodeModel(CodeModel cm)
        {
            var codeModel = cm as CodeModelTS;

            // we're guaranteed to be in our language-specific context here.
            SwaggerExtensions.NormalizeClientModel(codeModel);
            TransformHeaderCollectionParameterTypes(codeModel);
            PopulateAdditionalProperties(codeModel);
            NormalizeOdataFilterParameter(codeModel);
            PerformParameterMapping(codeModel);
            CreateModelTypeForOptionalClientProperties(codeModel);
            CreateModelTypesForOptionalMethodParameters(codeModel);
            AddEnumTypesToCodeModel(codeModel);
            EnsureParameterMethodSet(codeModel);
            CreateUniqueParameterMapperNames(codeModel);
            DisambiguateHeaderNames(codeModel);
            AddReadOnlyDocumentation(codeModel);
            ProcessAdditionalProperties(codeModel);

            if (codeModel.Settings.ModelDateTimeAsString)
            {
                ConvertDateTimeToString(codeModel);
            }

            return(codeModel);
        }
        public override CodeModelTf TransformCodeModel(CodeModel codeModel)
        {
            var model = base.TransformCodeModel(codeModel);

            SwaggerExtensions.NormalizeClientModel(model);
            CreateTransformers().ForEach(tr => tr.Transform(model));
            return(model);
        }
 /// <summary>
 /// Normalizes client model by updating names and types to be language specific.
 /// </summary>
 /// <param name="serviceClient"></param>
 public override void NormalizeClientModel(ServiceClient serviceClient)
 {
     SwaggerExtensions.NormalizeClientModel(serviceClient, Settings);
     PopulateAdditionalProperties(serviceClient);
     CodeNamer.NormalizeClientModel(serviceClient);
     CodeNamer.ResolveNameCollisions(serviceClient, Settings.Namespace,
                                     Settings.Namespace + "::Models");
 }
Exemple #7
0
        /// <summary>
        /// Changes paginated method signatures to return Page type.
        /// </summary>
        /// <param name="serviceClient"></param>
        /// <param name="pageClasses"></param>
        public virtual void NormalizePaginatedMethods(ServiceClient serviceClient, IDictionary <KeyValuePair <string, string>, string> pageClasses)
        {
            if (serviceClient == null)
            {
                throw new ArgumentNullException("serviceClient");
            }

            var convertedTypes = new Dictionary <IType, CompositeType>();

            foreach (var method in serviceClient.Methods.Where(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension)))
            {
                string nextLinkString;
                string pageClassName = GetPagingSetting(method.Extensions, pageClasses, out nextLinkString);
                if (string.IsNullOrEmpty(pageClassName))
                {
                    continue;
                }
                var pageTypeFormat  = "{0}<{1}>";
                var ipageTypeFormat = "Microsoft.Rest.Azure.IPage<{0}>";
                if (string.IsNullOrWhiteSpace(nextLinkString))
                {
                    ipageTypeFormat = "System.Collections.Generic.IEnumerable<{0}>";
                }


                foreach (var responseStatus in method.Responses
                         .Where(r => r.Value.Body is CompositeType).Select(s => s.Key).ToArray())
                {
                    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)
                    {
                        var pagableTypeName  = string.Format(CultureInfo.InvariantCulture, pageTypeFormat, pageClassName, sequenceType.ElementType.Name);
                        var ipagableTypeName = string.Format(CultureInfo.InvariantCulture, ipageTypeFormat, sequenceType.ElementType.Name);

                        CompositeType pagedResult = new CompositeType
                        {
                            Name = pagableTypeName
                        };
                        pagedResult.Extensions[AzureExtensions.ExternalExtension] = true;
                        pagedResult.Extensions[AzureExtensions.PageableExtension] = ipagableTypeName;

                        convertedTypes[method.Responses[responseStatus].Body] = pagedResult;
                        method.Responses[responseStatus] = new Response(pagedResult, method.Responses[responseStatus].Headers);
                    }
                }

                if (convertedTypes.ContainsKey(method.ReturnType.Body))
                {
                    method.ReturnType = new Response(convertedTypes[method.ReturnType.Body],
                                                     method.ReturnType.Headers);
                }
            }

            SwaggerExtensions.RemoveUnreferencedTypes(serviceClient, new HashSet <string>(convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name)));
        }
Exemple #8
0
        public void TestClientModelWithPayloadFlatteningViaXMSClientFlatten()
        {
            var setting = new Settings
            {
                Namespace = "Test",
                Input     = Path.Combine("Swagger", "swagger-x-ms-client-flatten.json")
            };
            var modeler     = new SwaggerModeler(setting);
            var clientModel = modeler.Build();

            SwaggerExtensions.NormalizeClientModel(clientModel, setting);

            Assert.NotNull(clientModel);
            Assert.Equal(8, clientModel.ModelTypes.Count);
            Assert.True(clientModel.ModelTypes.Any(m => m.Name == "BaseProduct"));
            Assert.True(clientModel.ModelTypes.Any(m => m.Name == "SimpleProduct"));
            Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ConflictedProduct"));
            Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ConflictedProductProperties")); // Since it's referenced in the response
            Assert.True(clientModel.ModelTypes.Any(m => m.Name == "RecursiveProduct"));
            Assert.True(clientModel.ModelTypes.Any(m => m.Name == "Error"));
            Assert.True(clientModel.ModelTypes.Any(m => m.Name == "ProductWithInheritance"));
            Assert.True(clientModel.ModelTypes.Any(m => m.Name == "BaseFlattenedProduct"));

            var simpleProduct = clientModel.ModelTypes.First(m => m.Name == "SimpleProduct");

            Assert.True(simpleProduct.Properties.Any(p => p.SerializedName == "details.max_product_display_name" &&
                                                     p.Name == "max_product_display_name"));
            Assert.True(simpleProduct.Properties.Any(p => p.SerializedName == "details.max_product_capacity" &&
                                                     p.Name == "max_product_capacity"));
            Assert.True(simpleProduct.Properties.Any(p => p.SerializedName == "details.max_product_image.@odata\\\\.value" &&
                                                     p.Name == "@odata.value"));

            var conflictedProduct = clientModel.ModelTypes.First(m => m.Name == "ConflictedProduct");

            Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "max_product_display_name" &&
                                                         p.Name == "max_product_display_name"));
            Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "details.max_product_display_name" &&
                                                         p.Name == "ConflictedProductProperties_max_product_display_name"));
            Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "simpleDetails.max_product_display_name" &&
                                                         p.Name == "SimpleProductProperties_max_product_display_name"));
            Assert.True(conflictedProduct.Properties.Any(p => p.SerializedName == "details.base_product_description" &&
                                                         p.Name == "ConflictedProduct_base_product_description"));

            var recursiveProduct = clientModel.ModelTypes.First(m => m.Name == "RecursiveProduct");

            Assert.True(recursiveProduct.Properties.Any(p => p.SerializedName == "properties.name" &&
                                                        p.Name == "name"));
            Assert.True(recursiveProduct.Properties.Any(p => p.SerializedName == "properties.parent" &&
                                                        p.Name == "parent"));

            var error = clientModel.ModelTypes.First(m => m.Name == "Error");

            Assert.Equal(3, error.Properties.Count);
            Assert.True(error.Properties.Any(p => p.SerializedName == "code" && p.Name == "code"));
            Assert.True(error.Properties.Any(p => p.SerializedName == "message" && p.Name == "message"));
            Assert.True(error.Properties.Any(p => p.SerializedName == "parentError" && p.Name == "parentError"));
            Assert.True(error.Properties.First(p => p.SerializedName == "parentError" && p.Name == "parentError").Type == error);
        }
Exemple #9
0
        public void GetPath_Should_ReturnFullDeleteMethod()
        {
            var controllerType = typeof(StubController);
            var actual         = SwaggerExtensions.GetPath("prefix", controllerType, controllerType.GetMethod(nameof(StubController.Delete)));

            const string expected = "/prefix/Stub/Delete(System.Guid id)";

            Assert.Equal(expected, actual);
        }
Exemple #10
0
        public void GetPath_Should_ReturnClearMethod()
        {
            var controllerType = typeof(StubController);
            var actual         = SwaggerExtensions.GetPath("prefix", controllerType, controllerType.GetMethod(nameof(StubController.Clear)));

            const string expected = "/prefix/Stub/Clear()";

            Assert.Equal(expected, actual);
        }
Exemple #11
0
        public override CodeModelRb TransformCodeModel(CodeModel cm)
        {
            var codeModel = cm as CodeModelRb;

            SwaggerExtensions.NormalizeClientModel(codeModel);
            PopulateAdditionalProperties(codeModel);
            Flattening(codeModel);

            return(codeModel);
        }
        public AnnotatedResponse(SwaggerResponseAttribute attr, ISwaggerModelCatalog modelCatalog)
        {
            Description = attr.Message;
            StatusCode  = (int)attr.Code;

            if (attr.Model != null)
            {
                Schema = SwaggerExtensions.GetSchema(modelCatalog, attr.Model);
            }
        }
Exemple #13
0
        /// <summary>
        /// Changes paginated method signatures to return Page type.
        /// </summary>
        /// <param name="serviceClient"></param>
        /// <param name="pageClasses"></param>
        public void NormalizePaginatedMethods(CodeModel serviceClient, IDictionary <KeyValuePair <string, string>, string> pageClasses)
        {
            if (serviceClient == null)
            {
                throw new ArgumentNullException("serviceClient");
            }

            var convertedTypes = new Dictionary <IModelType, IModelType>();

            foreach (MethodJva method in serviceClient.Methods.Where(m => m.Extensions.ContainsKey(AzureExtensions.PageableExtension)))
            {
                string nextLinkString;
                string pageClassName = GetPagingSetting(method.Extensions, pageClasses, out nextLinkString);
                if (string.IsNullOrEmpty(pageClassName))
                {
                    continue;
                }
                if (string.IsNullOrEmpty(nextLinkString))
                {
                    method.Extensions[AzureExtensions.PageableExtension] = null;
                }

                foreach (var responseStatus in method.Responses.Where(r => r.Value.Body is CompositeTypeJva).Select(s => s.Key).ToArray())
                {
                    var compositType = (CompositeTypeJva)method.Responses[responseStatus].Body;
                    var sequenceType = compositType.Properties.Select(p => p.ModelType).FirstOrDefault(t => t is SequenceTypeJva) as SequenceTypeJva;

                    // if the type is a wrapper over page-able response
                    if (sequenceType != null)
                    {
                        IModelType pagedResult;
                        pagedResult = new SequenceTypeJva
                        {
                            ElementType  = sequenceType.ElementType,
                            PageImplType = pageClassName
                        };

                        convertedTypes[method.Responses[responseStatus].Body] = pagedResult;
                        var resp = New <Response>(pagedResult, method.Responses[responseStatus].Headers) as ResponseJva;
                        resp.Parent = method;
                        method.Responses[responseStatus] = resp;
                    }
                }

                if (convertedTypes.ContainsKey(method.ReturnType.Body))
                {
                    var resp = New <Response>(convertedTypes[method.ReturnType.Body], method.ReturnType.Headers) as ResponseJva;
                    resp.Parent       = method;
                    method.ReturnType = resp;
                }
            }

            SwaggerExtensions.RemoveUnreferencedTypes(serviceClient, new HashSet <string>(convertedTypes.Keys.Cast <CompositeTypeJva>().Select(t => t.Name.ToString())));
        }
Exemple #14
0
        public override CodeModelJv TransformCodeModel(CodeModel cs)
        {
            var codeModel = cs as CodeModelJv;

            // we're guaranteed to be in our language-specific context here.

            // todo: these should be turned into individual transformers
            SwaggerExtensions.NormalizeClientModel(codeModel);

            return(codeModel);
        }
Exemple #15
0
        public override CodeModelPy TransformCodeModel(CodeModel cm)
        {
            var codeModel = cm as CodeModelPy;

            TransformGroupApiVersionToLocal(codeModel);
            SwaggerExtensions.NormalizeClientModel(codeModel);
            PopulateAdditionalProperties(codeModel);
            Flattening(codeModel);
            GenerateConstantProperties(codeModel);
            return(codeModel);
        }
        public override CodeModelGo TransformCodeModel(CodeModel cm)
        {
            var cmg = cm as CodeModelGo;

            SwaggerExtensions.ProcessGlobalParameters(cmg);
            // Add the current package name as a reserved keyword
            CodeNamerGo.Instance.ReserveNamespace(cm.Namespace);
            FixStutteringTypeNames(cmg);
            TransformEnumTypes(cmg);
            TransformMethods(cmg);
            TransformModelTypes(cmg);

            return(cmg);
        }
        public override CodeModelTS TransformCodeModel(CodeModel cm)
        {
            var codeModel = cm as CodeModelTS;

            // we're guaranteed to be in our language-specific context here.
            SwaggerExtensions.NormalizeClientModel(codeModel);
            PopulateAdditionalProperties(codeModel);
            NormalizeOdataFilterParameter(codeModel);
            PerformParameterMapping(codeModel);
            CreateModelTypeForOptionalClientProperties(codeModel);
            CreateModelTypesForOptionalMethodParameters(codeModel);
            AddEnumTypesToCodeModel(codeModel);
            return(codeModel);
        }
        public override CodeModelSwift TransformCodeModel(CodeModel cm)
        {
            var cmg = cm as CodeModelSwift;

            SwaggerExtensions.ProcessGlobalParameters(cmg);
            // Add the current package name as a reserved keyword
            TransformEnumTypes(cmg);
            TransformModelTypes(cmg);
            TransformMethods(cmg);
            AppendTypeSpecifier(cmg);
            AzureExtensions.ProcessParameterizedHost(cmg);

            return(cmg);
        }
        /// <summary>
        ///     Changes paginated method signatures to return Page type.
        /// </summary>
        /// <param name="codeModel"></param>
        private void NormalizePaginatedMethods(CodeModelPya codeModel)
        {
            if (codeModel == null)
            {
                throw new ArgumentNullException("codeModel");
            }

            var convertedTypes = new Dictionary <IModelType, Response>();

            foreach (MethodPya method in codeModel.Methods.Where(m => m is MethodPya && 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.ModelType).FirstOrDefault(t => t is SequenceType) as SequenceType;

                    // if the type is a wrapper over page-able response
                    if (sequenceType != null)
                    {
                        var    valueType     = sequenceType.ElementType;
                        string valueTypeName = valueType.Name;
                        if (!codeModel.PageClasses.ContainsKey(valueTypeName))
                        {
                            codeModel.PageClasses.Add(valueTypeName, new Dictionary <int, string>());
                        }
                        var pagableTypeName = GetPagingSetting(codeModel, compositType, method.Extensions, valueType,
                                                               codeModel.PageClasses[valueTypeName], method.SerializedName);

                        var pagedResult = New <CompositeType>(pagableTypeName);

                        // make sure the parent reference is set.
                        pagedResult.CodeModel = codeModel;

                        method.PagedResponseContentClass = valueType; // Save the content type model

                        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(codeModel, new HashSet <string>(convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name.Value)));
        }
Exemple #20
0
        public override CodeModelGo TransformCodeModel(CodeModel cm)
        {
            var cmg = cm as CodeModelGo;

            SwaggerExtensions.ProcessGlobalParameters(cmg);
            TransformEnumTypes(cmg);
            TransformModelTypes(cmg);
            TransformMethods(cmg);
            SwaggerExtensions.ProcessParameterizedHost(cmg);
            FixStutteringTypeNames(cmg);
            AssureUniqueNames(cmg);
            TransformPropertyTypes(cmg);

            return(cmg);
        }
Exemple #21
0
        public override CodeModelPy TransformCodeModel(CodeModel cm)
        {
            var codeModel = cm as CodeModelPy;

            // Put the initial namespace value, not transformed by the Core
            // Note that the "Else" is not supposed to be used, since Autorest
            // provides a default value now for Namespace, so Namespace is never empty.
            codeModel.Namespace = Settings.Instance.Namespace.Else(codeModel.Name.ToPythonCase().ToLower());

            TransformGroupApiVersionToLocal(codeModel);
            SwaggerExtensions.NormalizeClientModel(codeModel);
            PopulateAdditionalProperties(codeModel);
            Flattening(codeModel);
            GenerateConstantProperties(codeModel);
            return(codeModel);
        }
Exemple #22
0
        public override CodeModelCs TransformCodeModel(CodeModel cs)
        {
            var codeModel = cs as CodeModelCs;

            // we're guaranteed to be in our language-specific context here.

            // add the Credentials
            PopulateAdditionalProperties(codeModel);

            // todo: these should be turned into individual transformers
            SwaggerExtensions.NormalizeClientModel(codeModel);

            // Do parameter transformations
            TransformParameters(codeModel);

            return(codeModel);
        }
Exemple #23
0
        /// <summary>
        /// Normalizes client model by updating names and types to be language specific.
        /// </summary>
        /// <param name="serviceClient"></param>
        public override void NormalizeClientModel(ServiceClient serviceClient)
        {
            // Don't add pagable/longrunning method since we already handle ourself.
            Settings.AddCredentials = true;
            AzureExtensions.ProcessClientRequestIdExtension(serviceClient);
            AzureExtensions.UpdateHeadMethods(serviceClient);
            AzureExtensions.ParseODataExtension(serviceClient);
            SwaggerExtensions.FlattenModels(serviceClient);
            ParameterGroupExtensionHelper.AddParameterGroups(serviceClient);
            AzureExtensions.AddAzureProperties(serviceClient);
            AzureExtensions.SetDefaultResponses(serviceClient);
            CorrectFilterParameters(serviceClient);

            base.NormalizeClientModel(serviceClient);
            NormalizeApiVersion(serviceClient);
            NormalizePaginatedMethods(serviceClient);
        }
Exemple #24
0
        /// <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 override CodeModelGo TransformCodeModel(CodeModel cm)
        {
            var cmg = cm as CodeModelGo;

            SwaggerExtensions.ProcessGlobalParameters(cmg);
            TransformEnumTypes(cmg);
            TransformModelTypes(cmg);
            // FixUpPolymorphicTypes can generate new enum types so to avoid
            // name collisions call it after transforming enums and models
            FixUpPolymorphicTypes(cmg);
            TransformMethods(cmg);
            SwaggerExtensions.ProcessParameterizedHost(cmg);
            FixStutteringTypeNames(cmg);
            AssureUniqueNames(cmg);
            TransformPropertyTypes(cmg);

            return(cmg);
        }
Exemple #26
0
        public override CodeModelGo TransformCodeModel(CodeModel cm)
        {
            var cmg = cm as CodeModelGo;

            // DON'T EVER CHANGE THE ORDERING OF THESE METHODS, CHANGING THE ORDER OF THESE METHODS MIGHT LEAD TO UNEXPECTED RESULTS
            SwaggerExtensions.ProcessGlobalParameters(cmg);
            TransformEnumTypes(cmg);
            TransformModelTypes(cmg);
            // FixUpPolymorphicTypes can generate new enum types so to avoid
            // name collisions call it after transforming enums and models
            FixUpPolymorphicTypes(cmg);
            TransformMethods(cmg);
            SwaggerExtensions.ProcessParameterizedHost(cmg);
            FixStutteringTypeNames(cmg);
            AssureUniqueNames(cmg);
            TransformPropertyTypes(cmg);

            return(cmg);
        }
        public void TestClientModelClientName()
        {
            using (NewContext)
            {
                var setting = new Settings
                {
                    Namespace = "Test",
                    Input     = Path.Combine("Swagger", "swagger-x-ms-client-name.json")
                };

                var modeler     = new SwaggerModeler();
                var clientModel = modeler.Build();
                SwaggerExtensions.NormalizeClientModel(clientModel);

                Assert.NotNull(clientModel);
                Assert.Equal(2, clientModel.Methods.Count);
                Assert.Equal(2, clientModel.Methods[0].Parameters.Where(p => !p.IsClientProperty).Count());
                Assert.Equal(0, clientModel.Methods[1].Parameters.Where(p => !p.IsClientProperty).Count());

                Assert.Equal("subscription", clientModel.Methods[0].Parameters[0].Name);
                Assert.Equal("version", clientModel.Methods[0].Parameters[1].Name);
                Assert.Equal("subscriptionId", clientModel.Methods[0].Parameters[0].Name.FixedValue);
                Assert.Equal("apiVersion", clientModel.Methods[0].Parameters[1].Name.FixedValue);

                Assert.Equal(2, clientModel.Properties.Count);
                Assert.Equal("Subscription", clientModel.Properties[0].Name);
                Assert.Equal("_version", clientModel.Properties[1].Name);
                Assert.Equal("subscriptionId", clientModel.Properties[0].Name.FixedValue);
                Assert.Equal("apiVersion", clientModel.Properties[1].Name.FixedValue);

                Assert.Equal(1, clientModel.ModelTypes.Count);

                var type = clientModel.ModelTypes.First();

                Assert.Equal("ErrorCode", type.Properties[0].Name);
                Assert.Equal("ErrorMessage", type.Properties[1].Name);
                Assert.Equal("ParentError", type.Properties[2].Name);

                Assert.Equal("code", type.Properties[0].Name.FixedValue);
                Assert.Equal("message", type.Properties[1].Name.FixedValue);
                Assert.Equal("parentError", type.Properties[2].Name.FixedValue);
            }
        }
        public void TestClientNameRubyNormalization()
        {
            var setting = new Settings
            {
                Namespace = "Test",
                Input     = Path.Combine("Swagger", "swagger-x-ms-client-name.json")
            };

            var modeler     = new SwaggerModeler(setting);
            var clientModel = modeler.Build();

            SwaggerExtensions.NormalizeClientModel(clientModel, setting);
            var namer = new RubyCodeNamer();

            namer.NormalizeClientModel(clientModel);

            Assert.NotNull(clientModel);
            Assert.Equal(2, clientModel.Methods.Count);

            Assert.Equal(2, clientModel.Methods[0].Parameters.Where(p => !p.IsClientProperty).Count());

            Assert.Equal("subscription", clientModel.Methods[0].Parameters[0].GetClientName());
            Assert.Equal("version", clientModel.Methods[0].Parameters[1].GetClientName());
            Assert.Equal("subscription", clientModel.Methods[0].Parameters[0].Name);
            Assert.Equal("version", clientModel.Methods[0].Parameters[1].Name);

            Assert.Equal(2, clientModel.Properties.Count);
            Assert.Equal(0, clientModel.Methods[1].Parameters.Where(p => !p.IsClientProperty).Count());

            Assert.Equal("subscription", clientModel.Properties[0].GetClientName());
            Assert.Equal("_version", clientModel.Properties[1].GetClientName());
            Assert.Equal("subscription", clientModel.Properties[0].Name);
            Assert.Equal("_version", clientModel.Properties[1].Name);

            var type = clientModel.ModelTypes.First();

            Assert.Equal("error_code", type.Properties[0].Name);
            Assert.Equal("error_message", type.Properties[1].Name);
            Assert.Equal("parent_error", type.Properties[2].Name);
        }
Exemple #29
0
        public override CodeModelGo TransformCodeModel(CodeModel cm)
        {
            var cmg = cm as CodeModelGo;

            // DON'T EVER CHANGE THE ORDERING OF THESE METHODS, CHANGING THE ORDER OF THESE METHODS MIGHT LEAD TO UNEXPECTED RESULTS
            SwaggerExtensions.ProcessGlobalParameters(cmg);
            TransformEnumTypes(cmg);
            TransformModelTypes(cmg);
            // FixUpPolymorphicTypes can generate new enum types so to avoid
            // name collisions call it after transforming enums and models
            FixUpPolymorphicTypes(cmg);
            TransformMethods(cmg);
            SwaggerExtensions.ProcessParameterizedHost(cmg);
            FixStutteringTypeNames(cmg);
            // Get the setting of enum prefix
            var enumPrefix = Settings.Instance.Host.GetValue <bool>("enum-prefix").Result;

            TransfromEnumValues(cmg, enumPrefix);
            TransformPropertyTypes(cmg);

            return(cmg);
        }
Exemple #30
0
        public override CodeModelJs TransformCodeModel(CodeModel cm)
        {
            var codeModel = cm as CodeModelJs;

            // we're guaranteed to be in our language-specific context here.

            SwaggerExtensions.NormalizeClientModel(codeModel);
            PopulateAdditionalProperties(codeModel);

            NormalizeOdataFilterParameter(codeModel);

            foreach (var method in codeModel.Methods)
            {
                foreach (var parameterTransformation in method.InputParameterTransformation)
                {
                    parameterTransformation.OutputParameter.Name =
                        method.GetUniqueName(
                            CodeNamer.Instance.GetParameterName(parameterTransformation.OutputParameter.GetClientName()));

                    foreach (var parameterMapping in parameterTransformation.ParameterMappings)
                    {
                        if (parameterMapping.InputParameterProperty != null)
                        {
                            parameterMapping.InputParameterProperty =
                                CodeNamer.Instance.GetPropertyName(parameterMapping.InputParameterProperty);
                        }

                        if (parameterMapping.OutputParameterProperty != null)
                        {
                            parameterMapping.OutputParameterProperty =
                                CodeNamer.Instance.GetPropertyName(parameterMapping.OutputParameterProperty);
                        }
                    }
                }
            }

            return(codeModel);
        }