public void AddVerboseLog(int nodeId, string msg) { if (LogLevel == LoggingLevel.Verbose) { AzureExtensions.LogMessageFile("[UmbracoExamine] (" + ProviderName + ")" + msg + ". " + nodeId); } }
public void ConvertsPageResultsToPageTypeTest() { using (NewContext) { var settings = new Settings { Input = Path.Combine(Core.Utilities.Extensions.CodeBaseDirectory, "Resource", "azure-paging.json") }; var modeler = new SwaggerModeler(); var codeModel = modeler.Build(); AzureExtensions.NormalizeAzureClientModel(codeModel); Assert.Equal(7, codeModel.Methods.Count); Assert.Equal(1, codeModel.Methods.Count(m => m.Name == "GetSinglePage")); Assert.Equal(0, codeModel.Methods.Count(m => m.Name == "GetSinglePageNext")); Assert.Equal(1, codeModel.Methods.Count(m => m.Name == "PutSinglePage")); Assert.Equal(1, codeModel.Methods.Count(m => m.Name == "PutSinglePageSpecialNext")); Assert.Equal("ProductResult", codeModel.Methods[0].ReturnType.Body.Name); Assert.Equal("object", codeModel.Methods[1].ReturnType.Body.Name.ToLowerInvariant()); Assert.Equal("ProductResult", codeModel.Methods[1].Responses.ElementAt(0).Value.Body.Name); Assert.Equal("string", codeModel.Methods[1].Responses.ElementAt(1).Value.Body.Name.ToLowerInvariant()); Assert.Equal("object", codeModel.Methods[2].ReturnType.Body.Name.ToLowerInvariant()); Assert.Equal("ProductResult", codeModel.Methods[2].Responses.ElementAt(0).Value.Body.Name); Assert.Equal("ProductResult2", codeModel.Methods[2].Responses.ElementAt(1).Value.Body.Name); Assert.Equal("object", codeModel.Methods[3].ReturnType.Body.Name.ToLowerInvariant()); Assert.Equal("ProductResult", codeModel.Methods[3].Responses.ElementAt(0).Value.Body.Name); Assert.Equal("ProductResult3", codeModel.Methods[3].Responses.ElementAt(1).Value.Body.Name); Assert.Equal(8, codeModel.ModelTypes.Count); } }
public override CodeModelPya TransformCodeModel(CodeModel cm) { var codeModel = (CodeModelPya)cm; TransformPagingMethods(codeModel); // We do most of "NormalizeAzureClientModel", but not everything // since some is handled manually here Settings.Instance.AddCredentials = true; // This extension from general extensions must be run prior to Azure specific extensions. AzureExtensions.ProcessParameterizedHost(codeModel); AzureExtensions.ProcessClientRequestIdExtension(codeModel); AzureExtensions.UpdateHeadMethods(codeModel); AzureExtensions.ParseODataExtension(codeModel); AzureExtensions.ProcessGlobalParameters(codeModel); AzureExtensions.FlattenModels(codeModel); AzureExtensions.FlattenMethodParameters(codeModel); ParameterGroupExtensionHelper.AddParameterGroups(codeModel); // AzureExtensions.AddLongRunningOperations(codeModel); -- Replaced by Python version AddAzureProperties(codeModel); AzureExtensions.SetDefaultResponses(codeModel); // AzureExtensions.AddPageableMethod(codeModel); -- Replaced by Python version // End of mock "NormalizeAzureClientModel" CorrectFilterParameters(codeModel); Base.TransformCodeModel(codeModel); NormalizePaginatedMethods(codeModel); return(codeModel); }
CodeModelCsa ITransformer <CodeModelCsa> .TransformCodeModel(CodeModel cs) { var codeModel = cs as CodeModelCsa; // we're guaranteed to be in our language-specific context here. Settings.Instance.AddCredentials = true; // add the Credentials // PopulateAdditionalProperties(codeModel); // Do parameter transformations TransformParameters(codeModel); // todo: these should be turned into individual transformers AzureExtensions.NormalizeAzureClientModel(codeModel); NormalizePaginatedMethods(codeModel); NormalizeODataMethods(codeModel); foreach (var model in codeModel.ModelTypes) { if (model.Extensions.ContainsKey(AzureExtensions.AzureResourceExtension) && (bool)model.Extensions[AzureExtensions.AzureResourceExtension]) { model.BaseModelType = New <ILiteralType>("Microsoft.Rest.Azure.IResource", new { SerializedName = "Microsoft.Rest.Azure.IResource" }) as CompositeType; } } return(codeModel); }
CodeModelCsaf ITransformer <CodeModelCsaf> .TransformCodeModel(CodeModel cs) { var codeModel = cs as CodeModelCsaf; Settings.Instance.AddCredentials = true; // todo: these should be turned into individual transformers AzureExtensions.NormalizeAzureClientModel(codeModel); // Do parameter transformations TransformParameters(codeModel); // Fluent Specific stuff. MoveResourceTypeProperties(codeModel); // call this before normalizing the resource types NormalizeResourceTypes(codeModel); NormalizeTopLevelTypes(codeModel); UseSubResourceForResourceProperties(codeModel); NormalizeModelProperties(codeModel); NormalizePaginatedMethods(codeModel); NormalizeODataMethods(codeModel); NormalizeEnumTypesWithNoNames(codeModel); return(codeModel); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient">The service client.</param> public override void NormalizeClientModel(ServiceClient serviceClient) { Settings.AddCredentials = true; AzureExtensions.NormalizeAzureClientModel(serviceClient, Settings, CodeNamer); CorrectFilterParameters(serviceClient); base.NormalizeClientModel(serviceClient); }
public override CodeModelJv TransformCodeModel(CodeModel cm) { var codeModel = cm as CodeModelJva; // we're guaranteed to be in our language-specific context here. Settings.Instance.AddCredentials = true; // This extension from general extensions must be run prior to Azure specific extensions. AzureExtensions.ProcessParameterizedHost(codeModel); AzureExtensions.ProcessClientRequestIdExtension(codeModel); AzureExtensions.UpdateHeadMethods(codeModel); AzureExtensions.ProcessGlobalParameters(codeModel); AzureExtensions.FlattenModels(codeModel); AzureExtensions.FlattenMethodParameters(codeModel); ParameterGroupExtensionHelper.AddParameterGroups(codeModel); AddLongRunningOperations(codeModel); AzureExtensions.AddAzureProperties(codeModel); AzureExtensions.SetDefaultResponses(codeModel); // set Parent on responses (required for pageable) foreach (MethodJva method in codeModel.Methods) { foreach (ResponseJva response in method.Responses.Values) { response.Parent = method; } (method.DefaultResponse as ResponseJva).Parent = method; method.ReturnTypeJva.Parent = method; } AzureExtensions.AddPageableMethod(codeModel); // pluralize method groups foreach (var mg in codeModel.Operations) { mg.Name.OnGet += name => name.IsNullOrEmpty() || name.EndsWith("s", StringComparison.OrdinalIgnoreCase) ? $"{name}" : $"{name}s"; } NormalizePaginatedMethods(codeModel, codeModel.pageClasses); // determine inner models NormalizeTopLevelTypes(codeModel); // param order (PATH first) foreach (MethodJva method in codeModel.Methods) { var ps = method.Parameters.ToList(); method.ClearParameters(); foreach (var p in ps.Where(x => x.Location == ParameterLocation.Path)) { method.Add(p); } foreach (var p in ps.Where(x => x.Location != ParameterLocation.Path)) { method.Add(p); } } return(codeModel); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient"></param> public override void NormalizeClientModel(ServiceClient serviceClient) { AzureExtensions.NormalizeAzureClientModel(serviceClient, Settings, _namer); _namer.NormalizeClientModel(serviceClient); _namer.ResolveNameCollisions(serviceClient, Settings.Namespace, Settings.Namespace + ".Models"); _namer.NormalizePaginatedMethods(serviceClient, pageClasses); }
/// <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 = "IPage<{0}>"; if (string.IsNullOrWhiteSpace(nextLinkString)) { ipageTypeFormat = "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); } } AzureExtensions.RemoveUnreferencedTypes(serviceClient, convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name)); }
public override CodeModel TransformCodeModel(CodeModel codeModel) { // we're guaranteed to be in our language-specific context here. Settings.Instance.AddCredentials = true; // todo: these should be turned into individual transformers AzureExtensions.NormalizeAzureClientModel(codeModel); return(codeModel); }
public AzureMethodTemplateModel(Method source, ServiceClient serviceClient) : base(source, serviceClient) { if (source == null) { throw new ArgumentNullException("source"); } this.ClientRequestIdString = AzureExtensions.GetClientRequestIdString(source); this.RequestIdString = AzureExtensions.GetRequestIdString(source); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient"></param> public override void NormalizeClientModel(ServiceClient serviceClient) { AzureExtensions.NormalizeAzureClientModel(serviceClient, Settings, _namer); _namer.NormalizeClientModel(serviceClient); _namer.ResolveNameCollisions(serviceClient, Settings.Namespace, Settings.Namespace + ".Models"); _namer.NormalizeResourceTypes(serviceClient); _namer.NormalizeTopLevelTypes(serviceClient); _namer.NormalizeModelProperties(serviceClient); _namer.NormalizePaginatedMethods(serviceClient, PageClasses); _namer.NormalizeODataMethods(serviceClient); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient">The service client.</param> public override void NormalizeClientModel(ServiceClient serviceClient) { Settings.AddCredentials = true; AzureExtensions.UpdateHeadMethods(serviceClient); AzureExtensions.ParseODataExtension(serviceClient); AzureExtensions.AddPageableMethod(serviceClient, CodeNamer); AzureExtensions.AddLongRunningOperations(serviceClient); AzureExtensions.AddAzureProperties(serviceClient); AzureExtensions.SetDefaultResponses(serviceClient); CorrectFilterParameters(serviceClient); base.NormalizeClientModel(serviceClient); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient"></param> public override void NormalizeClientModel(ServiceClient serviceClient) { // MethodNames are normalized explicitly to provide a consitent method name while // generating cloned methods for long running operations with reserved words. For // example - beginDeleteMethod() insteadof beginDelete() as delete is a reserved word. Namer.NormalizeMethodNames(serviceClient); AzureExtensions.NormalizeAzureClientModel(serviceClient, Settings, Namer); base.NormalizeClientModel(serviceClient); NormalizeApiVersion(serviceClient); NormalizePaginatedMethods(serviceClient); ExtendAllResourcesToBaseResource(serviceClient); }
CodeModelRba ITransformer <CodeModelRba> .TransformCodeModel(CodeModel cs) { var codeModel = cs as CodeModelRba; PopulateAdditionalProperties(codeModel); Singleton <Settings> .Instance.AddCredentials = true; AzureExtensions.NormalizeAzureClientModel(codeModel); CorrectFilterParameters(codeModel); AddRubyPageableMethod(codeModel); ApplyPagination(codeModel); return(codeModel); }
public AzureMethodTemplateModel(Method source, ServiceClient serviceClient) : base(source, serviceClient) { if (source == null) { throw new ArgumentNullException("source"); } this.ClientRequestIdString = AzureExtensions.GetClientRequestIdString(source); this.RequestIdString = AzureExtensions.GetRequestIdString(source); _returnTypeModel = new AzureResponseModel(ReturnType, this); _responseModels = new Dictionary <HttpStatusCode, ResponseModel>(); Responses.ForEach(r => _responseModels.Add(r.Key, new AzureResponseModel(r.Value, this))); }
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> /// Initializes a new instance of the AzureMethodTemplateModel class. /// </summary> /// <param name="source">The method current model is built for.</param> /// <param name="serviceClient">The service client - main point of access to the SDK.</param> public AzureMethodTemplateModel(Method source, ServiceClient serviceClient) : base(source, serviceClient) { if (source == null) { throw new ArgumentNullException("source"); } ParameterTemplateModels.Clear(); source.Parameters.ForEach(p => ParameterTemplateModels.Add(new AzureParameterTemplateModel(p))); this.ClientRequestIdString = AzureExtensions.GetClientRequestIdString(source); this.RequestIdString = AzureExtensions.GetRequestIdString(source); }
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); AzureExtensions.ProcessParameterizedHost(cmg); return(cmg); }
/// <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.UpdateHeadMethods(serviceClient); AzureExtensions.ParseODataExtension(serviceClient); AzureExtensions.FlattenResourceProperties(serviceClient); AzureExtensions.AddAzureProperties(serviceClient); AzureExtensions.SetDefaultResponses(serviceClient); AzureExtensions.AddParameterGroups(serviceClient); base.NormalizeClientModel(serviceClient); NormalizeApiVersion(serviceClient); NormalizePaginatedMethods(serviceClient); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient"></param> public override void NormalizeClientModel(ServiceClient serviceClient) { Settings.AddCredentials = true; AzureExtensions.UpdateHeadMethods(serviceClient); AzureExtensions.ParseODataExtension(serviceClient); AzureExtensions.FlattenResourceProperties(serviceClient); AzureExtensions.AddPageableMethod(serviceClient, _namer); AzureExtensions.AddAzureProperties(serviceClient); AzureExtensions.SetDefaultResponses(serviceClient); AzureExtensions.AddParameterGroups(serviceClient); _namer.NormalizeClientModel(serviceClient); _namer.ResolveNameCollisions(serviceClient, Settings.Namespace, Settings.Namespace + ".Models"); _namer.NormalizePaginatedMethods(serviceClient, pageClasses); ExtendAllResourcesToBaseResource(serviceClient); }
/// <summary> /// Creates azure specific properties. /// </summary> /// <param name="codeModelient"></param> private static void AddAzureProperties(CodeModel codeModel) { var acceptLanguage = codeModel.Properties .FirstOrDefault(p => AzureExtensions.AcceptLanguage.EqualsIgnoreCase(p.SerializedName)); AzureExtensions.AddAzureProperties(codeModel); codeModel.Remove(codeModel.Properties.FirstOrDefault(p => p.Name == "long_running_operation_retry_timeout")); codeModel.Remove(codeModel.Properties.FirstOrDefault(p => p.Name == "generate_client_request_id")); codeModel.Remove(codeModel.Properties.FirstOrDefault(p => p.Name == "accept_language")); if (acceptLanguage != null) // && acceptLanguage.DefaultValue != "en-US" { acceptLanguage.IsReadOnly = true; acceptLanguage.IsRequired = false; acceptLanguage.ModelType = New <PrimaryType>(KnownPrimaryType.String); codeModel.Add(acceptLanguage); } }
public AzureMethodTemplateModel(Method source, ServiceClient serviceClient) : base(source, serviceClient) { if (source == null) { throw new ArgumentNullException("source"); } this.ClientRequestIdString = AzureExtensions.GetClientRequestIdString(source); this.RequestIdString = AzureExtensions.GetRequestIdString(source); _returnTypeModel = new AzureResponseModel(ReturnType, this); _responseModels = new Dictionary <HttpStatusCode, ResponseModel>(); Responses.ForEach(r => _responseModels.Add(r.Key, new AzureResponseModel(r.Value, this))); if (this.IsPagingOperation || this.IsPagingNextOperation) { var ext = this.Extensions[AzureExtensions.PageableExtension] as Newtonsoft.Json.Linq.JContainer; pageClassName = (string)ext["className"] ?? "PageImpl"; } }
public AzureMethodTemplateModel(Method source, ServiceClient serviceClient, SyncMethodsGenerationMode syncWrappers) : base(source, serviceClient, syncWrappers) { if (source == null) { throw new ArgumentNullException("source"); } ParameterTemplateModels.Clear(); LogicalParameterTemplateModels.Clear(); source.Parameters.ForEach(p => ParameterTemplateModels.Add(new AzureParameterTemplateModel(p))); source.LogicalParameters.ForEach(p => LogicalParameterTemplateModels.Add(new AzureParameterTemplateModel(p))); if (MethodGroupName != ServiceClient.Name) { MethodGroupName = MethodGroupName + "Operations"; } this.ClientRequestIdString = AzureExtensions.GetClientRequestIdString(source); this.RequestIdString = AzureExtensions.GetRequestIdString(source); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient"></param> public override void NormalizeClientModel(ServiceClient serviceClient) { Settings.AddCredentials = true; // This extension from general extensions must be run prior to Azure specific extensions. AzureExtensions.ProcessParameterizedHost(serviceClient, Settings); AzureExtensions.ProcessClientRequestIdExtension(serviceClient); AzureExtensions.UpdateHeadMethods(serviceClient); AzureExtensions.FlattenModels(serviceClient); AzureExtensions.FlattenMethodParameters(serviceClient, Settings); ParameterGroupExtensionHelper.AddParameterGroups(serviceClient); AzureExtensions.AddLongRunningOperations(serviceClient); AzureExtensions.AddAzureProperties(serviceClient); AzureExtensions.SetDefaultResponses(serviceClient); AzureExtensions.AddPageableMethod(serviceClient, _namer); _namer.NormalizeClientModel(serviceClient); _namer.ResolveNameCollisions(serviceClient, Settings.Namespace, Settings.Namespace + ".Models"); _namer.NormalizePaginatedMethods(serviceClient, pageClasses); }
CodeModelCsaf ITransformer <CodeModelCsaf> .TransformCodeModel(CodeModel cs) { var codeModel = cs as CodeModelCsaf; // Do parameter transformations TransformParameters(codeModel); // todo: these should be turned into individual transformers AzureExtensions.NormalizeAzureClientModel(codeModel); // Fluent Specific stuff. NormalizeResourceTypes(codeModel); NormalizeTopLevelTypes(codeModel); NormalizeModelProperties(codeModel); NormalizePaginatedMethods(codeModel); NormalizeODataMethods(codeModel); return(codeModel); }
CodeModelTSa ITransformer <CodeModelTSa> .TransformCodeModel(CodeModel cm) { var codeModel = cm as CodeModelTSa; if (codeModel == null) { throw new InvalidCastException("Code Model is not a TypeScript Azure code model."); } // MethodNames are normalized explicitly to provide a consitent method name while // generating cloned methods for long running operations with reserved words. For // example - beginDeleteMethod() insteadof beginDelete() as delete is a reserved word. // Namer.NormalizeMethodNames(serviceClient); AzureExtensions.NormalizeAzureClientModel(codeModel); base.TransformCodeModel(codeModel); NormalizePaginatedMethods(codeModel); ExtendAllResourcesToBaseResource(codeModel); CreateModelTypeForOptionalClientProperties(codeModel); return(codeModel); }
/// <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 pagableTypeName = GetPagingSetting(method.Extensions, sequenceType.ElementType.Name); 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]; } } AzureExtensions.RemoveUnreferencedTypes(serviceClient, convertedTypes.Keys.Cast <CompositeType>().Select(t => t.Name)); }
public override CodeModelPya TransformCodeModel(CodeModel cm) { var codeModel = (CodeModelPya)cm; TransformPagingMethods(codeModel); // Don't add pagable/longrunning method since we already handle ourself. Settings.Instance.AddCredentials = true; AzureExtensions.ProcessClientRequestIdExtension(codeModel); AzureExtensions.UpdateHeadMethods(codeModel); AzureExtensions.ParseODataExtension(codeModel); SwaggerExtensions.FlattenModels(codeModel); ParameterGroupExtensionHelper.AddParameterGroups(codeModel); AddAzureProperties(codeModel); AzureExtensions.SetDefaultResponses(codeModel); CorrectFilterParameters(codeModel); Base.TransformCodeModel(codeModel); NormalizePaginatedMethods(codeModel); return(codeModel); }
/// <summary> /// Normalizes client model by updating names and types to be language specific. /// </summary> /// <param name="serviceClient"></param> public override void NormalizeClientModel(ServiceClient serviceClient) { AzureExtensions.NormalizeAzureClientModel(serviceClient, Settings); _namer.NormalizeClientModel(serviceClient); _namer.ResolveNameCollisions(serviceClient, Settings.Namespace, Settings.Namespace + ".Models"); _namer.NormalizePaginatedMethods(serviceClient, pageClasses); _namer.NormalizeODataMethods(serviceClient); if (serviceClient != null) { foreach (var model in serviceClient.ModelTypes) { if (model.Extensions.ContainsKey(AzureExtensions.AzureResourceExtension) && (bool)model.Extensions[AzureExtensions.AzureResourceExtension]) { model.BaseModelType = new CompositeType { Name = "IResource", SerializedName = "IResource" }; } } } }