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"
};
}
}
}
}
