public ServiceClientTemplateModel(ServiceClient serviceClient)
{
this.LoadFrom(serviceClient);
MethodTemplateModels = new List<MethodTemplateModel>();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient)));
}
public static void ProcessParameterizedHost(ServiceClient serviceClient, Settings settings)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (serviceClient.Extensions.ContainsKey(ParameterizedHostExtension) && !hostChecked)
{
SwaggerModeler modeler = new SwaggerModeler(settings);
modeler.Build();
var hostExtension = serviceClient.Extensions[ParameterizedHostExtension] as JObject;
if (hostExtension != null)
{
var hostTemplate = (string)hostExtension["hostTemplate"];
var parametersJson = hostExtension["parameters"].ToString();
if (!string.IsNullOrEmpty(parametersJson))
{
var jsonSettings = new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.None,
MetadataPropertyHandling = MetadataPropertyHandling.Ignore
};
var swaggerParams = JsonConvert.DeserializeObject<List<SwaggerParameter>>(parametersJson, jsonSettings);
foreach (var swaggerParameter in swaggerParams)
{
// Build parameter
var parameterBuilder = new ParameterBuilder(swaggerParameter, modeler);
var parameter = parameterBuilder.Build();
// check to see if the parameter exists in properties, and needs to have its name normalized
if (serviceClient.Properties.Any(p => p.SerializedName.Equals(parameter.SerializedName)))
{
parameter.ClientProperty = serviceClient.Properties.Single(p => p.SerializedName.Equals(parameter.SerializedName));
}
parameter.Extensions["hostParameter"] = true;
foreach (var method in serviceClient.Methods)
{
method.Parameters.Add(parameter);
}
}
serviceClient.BaseUrl = string.Format(CultureInfo.InvariantCulture, "{0}://{1}{2}",
modeler.ServiceDefinition.Schemes[0].ToString().ToLowerInvariant(),
hostTemplate, modeler.ServiceDefinition.BasePath);
}
}
}
hostChecked = true;
}
public void ParseWithEmptyServiceClient()
{
ServiceClient serviceClient = new ServiceClient();
IDictionary<string, ResourceSchema> schemas = ResourceSchemaParser.Parse(serviceClient);
Assert.NotNull(schemas);
Assert.Equal(0, schemas.Count);
}
public override async Task Generate(ServiceClient serviceClient)
{
var viewModel = new SampleViewModel();
var model = new SampleModel();
model.Model = viewModel;
await Write(model, Path.Combine("Models", "Pet.cs"));
}
public override async Task Generate(ServiceClient serviceClient)
{
var viewModel = new SampleViewModel();
var model = new SampleModel();
model.Model = viewModel;
await Write(model, "Models\\Pet.cs");
}
/// <summary>
/// Normalizes client model by updating names and types to be language specific.
/// </summary>
/// <param name="serviceClient"></param>
public override void NormalizeClientModel(ServiceClient serviceClient)
{
PopulateAdditionalProperties(serviceClient);
_namer.NormalizeClientModel(serviceClient);
_namer.ResolveNameCollisions(serviceClient, Settings.Namespace,
Settings.Namespace + ".Models");
}
/// <summary>
/// Changes paginated method signatures to return Page type.
/// </summary>
/// <param name="serviceClient"></param>
public virtual void NormalizePaginatedMethods(ServiceClient serviceClient)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
}
/// <summary>
/// Initializes a new instance of the AzureServiceClientTemplateModel class.
/// </summary>
/// <param name="serviceClient">The service client instance.</param>
public AzureServiceClientTemplateModel(ServiceClient serviceClient)
: base(serviceClient)
{
MethodTemplateModels.Clear();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient)));
}
/// <summary>
/// Initializes a new instance of the class MethodTemplateModel.
/// </summary>
/// <param name="source">The source object.</param>
/// <param name="serviceClient">The service client.</param>
public MethodTemplateModel(Method source, ServiceClient serviceClient)
{
this.LoadFrom(source);
ParameterTemplateModels = new List<ParameterTemplateModel>();
source.Parameters.ForEach(p => ParameterTemplateModels.Add(new ParameterTemplateModel(p)));
ServiceClient = serviceClient;
}
/// <summary>
/// Normalizes client model using Azure-specific extensions.
/// </summary>
/// <param name="serviceClient">Service client</param>
/// <param name="settings">AutoRest settings</param>
/// <param name="codeNamer">AutoRest settings</param>
/// <returns></returns>
public static void NormalizeAzureClientModel(ServiceClient serviceClient, Settings settings, CodeNamer codeNamer)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (codeNamer == null)
{
throw new ArgumentNullException("codeNamer");
}
settings.AddCredentials = true;
UpdateHeadMethods(serviceClient);
ParseODataExtension(serviceClient);
FlattenResourceProperties(serviceClient);
FlattenRequestPayload(serviceClient, settings);
AddLongRunningOperations(serviceClient);
AddAzureProperties(serviceClient);
SetDefaultResponses(serviceClient);
AddParameterGroups(serviceClient);
AddPageableMethod(serviceClient, codeNamer);
}
/// <summary>
/// Normalizes client model using generic extensions.
/// </summary>
/// <param name="serviceClient">Service client</param>
/// <param name="settings">AutoRest settings</param>
/// <returns></returns>
public static void NormalizeClientModel(ServiceClient serviceClient, Settings settings)
{
FlattenModels(serviceClient);
FlattenMethodParameters(serviceClient, settings);
ParameterGroupExtensionHelper.AddParameterGroups(serviceClient);
ProcessParameterizedHost(serviceClient, settings);
}
/// <summary>
/// Normalizes client model by updating names and types to be language specific.
/// </summary>
/// <param name="serviceClient"></param>
public override void NormalizeClientModel(ServiceClient serviceClient)
{
base.NormalizeClientModel(serviceClient);
_namer.NormalizeClientModel(serviceClient);
_namer.ResolveNameCollisions(serviceClient, Settings.Namespace,
Settings.Namespace + ".Models");
}
public override void NormalizeClientModel(ServiceClient client)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
base.NormalizeClientModel(client);
foreach (var method in client.Methods)
{
var scope = new ScopeProvider();
foreach (var parameter in method.Parameters)
{
if (parameter.ClientProperty != null)
{
parameter.Name = string.Format(CultureInfo.InvariantCulture,
"{0}.{1}",
method.Group == null ? "this" : "this.Client",
parameter.ClientProperty.Name);
}
else
{
parameter.Name = scope.GetVariableName(parameter.Name);
}
}
}
}
/// <summary>
/// Normalizes client model by updating names and types to be language specific.
/// </summary>
/// <param name="serviceClientModel"></param>
public override void NormalizeClientModel(ServiceClient serviceClientModel)
{
PopulateAdditionalProperties(serviceClientModel);
namingFramework.NormalizeClientModel(serviceClientModel);
namingFramework.ResolveNameCollisions(serviceClientModel, Settings.Namespace,
Settings.Namespace + "::Models");
}
private static async Task TestGenerate(string apiVersion, string[] methodUrls, string expectedJsonString)
{
MemoryFileSystem fileSystem = new MemoryFileSystem();
Settings settings = new Settings();
settings.FileSystem = fileSystem;
ServiceClient serviceClient = new ServiceClient();
serviceClient.ApiVersion = apiVersion;
foreach(string methodUrl in methodUrls)
{
serviceClient.Methods.Add(new Method()
{
Url = methodUrl,
HttpMethod = HttpMethod.Put,
});
}
await CreateGenerator(settings).Generate(serviceClient);
Assert.Equal(2, fileSystem.VirtualStore.Count);
string folderPath = fileSystem.VirtualStore.Keys.First();
Assert.Equal("Folder", fileSystem.VirtualStore[folderPath].ToString());
JObject expectedJSON = JObject.Parse(expectedJsonString);
string fileContents = fileSystem.VirtualStore[fileSystem.VirtualStore.Keys.Skip(1).First()].ToString();
JObject actualJson = JObject.Parse(fileContents);
Assert.Equal(expectedJSON, actualJson);
}
public void NormalizeClientModelDoesNothing()
{
ServiceClient serviceClient = new ServiceClient();
CreateGenerator().NormalizeClientModel(serviceClient);
// Nothing happens
}
public AzureMethodGroupTemplateModel(ServiceClient serviceClient, string methodGroupName)
: base(serviceClient, methodGroupName)
{
MethodTemplateModels.Clear();
Methods.Where(m => m.Group == MethodGroupName)
.ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient)));
}
/// <summary>
/// Normalizes client model using Azure-specific extensions.
/// </summary>
/// <param name="serviceClient">Service client</param>
/// <param name="settings">AutoRest settings</param>
/// <param name="codeNamer">AutoRest settings</param>
/// <returns></returns>
public static void NormalizeAzureClientModel(ServiceClient serviceClient, Settings settings, CodeNamer codeNamer)
{
if (serviceClient == null)
{
throw new ArgumentNullException("serviceClient");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (codeNamer == null)
{
throw new ArgumentNullException("codeNamer");
}
settings.AddCredentials = true;
// This extension from general extensions must be run prior to Azure specific extensions.
ProcessParameterizedHost(serviceClient, settings);
UpdateHeadMethods(serviceClient);
ParseODataExtension(serviceClient);
FlattenModels(serviceClient);
FlattenMethodParameters(serviceClient, settings);
AddParameterGroups(serviceClient);
AddLongRunningOperations(serviceClient);
AddAzureProperties(serviceClient);
SetDefaultResponses(serviceClient);
AddPageableMethod(serviceClient, codeNamer);
}
public MethodTemplateModel(Method source, ServiceClient serviceClient)
{
this.LoadFrom(source);
ParameterTemplateModels = new List<ParameterTemplateModel>();
source.Parameters.ForEach(p => ParameterTemplateModels.Add(new ParameterTemplateModel(p)));
ServiceClient = serviceClient;
if (source.Group != null)
{
OperationName = source.Group.ToPascalCase();
}
else
{
OperationName = serviceClient.Name;
}
AddCustomHeader = true;
string formatter;
foreach (var parameter in LocalParameters)
{
if (string.IsNullOrWhiteSpace(parameter.DefaultValue))
{
parameter.DefaultValue = PythonConstants.None;
}
}
foreach (Match m in Regex.Matches(Url, @"\{[\w]+:[\w]+\}"))
{
formatter = m.Value.Split(':').First() + '}';
Url = Url.Replace(m.Value, formatter);
}
}
/// <summary>
/// Recursively normalizes names in the client model
/// </summary>
/// <param name="client"></param>
public virtual void NormalizeClientModel(ServiceClient client)
{
if (client == null)
{
throw new ArgumentNullException("client");
}
client.Name = GetTypeName(client.Name);
client.Namespace = GetNamespaceName(client.Namespace);
foreach (var property in client.Properties)
{
property.Name = GetPropertyName(property.Name);
property.Type = NormalizeType(property.Type);
}
var normalizedModels = new List<CompositeType>();
foreach (var modelType in client.ModelTypes)
{
normalizedModels.Add(NormalizeType(modelType) as CompositeType);
}
client.ModelTypes.Clear();
normalizedModels.ForEach( (item) => client.ModelTypes.Add(item));
var normalizedEnums = new List<EnumType>();
foreach (var enumType in client.EnumTypes)
{
var normalizedType = NormalizeType(enumType) as EnumType;
if (normalizedType != null)
{
normalizedEnums.Add(NormalizeType(enumType) as EnumType);
}
}
client.EnumTypes.Clear();
normalizedEnums.ForEach((item) => client.EnumTypes.Add(item));
foreach (var method in client.Methods)
{
method.Name = GetMethodName(method.Name);
method.Group = GetTypeName(method.Group);
method.ReturnType = NormalizeType(method.ReturnType);
method.DefaultResponse = NormalizeType(method.DefaultResponse);
var normalizedResponses = new Dictionary<HttpStatusCode, IType>();
foreach (var statusCode in method.Responses.Keys)
{
normalizedResponses[statusCode] = NormalizeType(method.Responses[statusCode]);
}
method.Responses.Clear();
foreach (var statusCode in normalizedResponses.Keys)
{
method.Responses[statusCode] = normalizedResponses[statusCode];
}
foreach (var parameter in method.Parameters)
{
parameter.Name = GetParameterName(parameter.Name);
parameter.Type = NormalizeType(parameter.Type);
}
}
}
public ServiceClientTemplateModel(ServiceClient serviceClient, bool internalConstructors)
{
this.LoadFrom(serviceClient);
MethodTemplateModels = new List<MethodTemplateModel>();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient)));
ConstructorVisibility = internalConstructors ? "internal" : "public";
}
public ExtensionsTemplateModel(ServiceClient serviceClient, string operationName)
{
this.LoadFrom(serviceClient);
MethodTemplateModels = new List<MethodTemplateModel>();
ExtensionName = operationName ?? this.Name;
this.Methods.Where(m => m.Group == operationName)
.ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, 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)
{
AzureExtensions.NormalizeAzureClientModel(serviceClient, Settings, _namer);
_namer.NormalizeClientModel(serviceClient);
_namer.ResolveNameCollisions(serviceClient, Settings.Namespace,
Settings.Namespace + ".Models");
_namer.NormalizePaginatedMethods(serviceClient, pageClasses);
}
public AzureServiceClientTemplateModel(ServiceClient serviceClient, bool internalConstructors)
: base(serviceClient, internalConstructors)
{
// TODO: Initialized in the base constructor. Why Clear it?
MethodTemplateModels.Clear();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient)));
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
var serviceClientTemplateModel = new ServiceClientTemplateModel(serviceClient);
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientTemplate, serviceClient.Name.ToPascalCase() + "Impl.java");
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientInterfaceTemplate, serviceClient.Name.ToPascalCase() + ".java");
//Models
if (serviceClient.ModelTypes.Any())
{
foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine("models", modelType.Name.ToPascalCase() + ".java"));
}
}
//MethodGroups
if (serviceClientTemplateModel.MethodGroupModels.Any())
{
foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + "Impl.java");
var methodGroupInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = methodGroupModel
};
await Write(methodGroupInterfaceTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + ".java");
}
}
//Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine("models", enumTemplate.Model.Name.ToPascalCase() + ".java"));
}
}
public AzureServiceClientTemplateModel(ServiceClient serviceClient)
: base(serviceClient)
{
MethodTemplateModels.Clear();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient)));
ModelTemplateModels.RemoveAll(m => m.Extensions.ContainsKey(AzureCodeGenerator.ExternalExtension));
ModelTemplateModels.RemoveAll(m => m.Extensions.ContainsKey(AzureCodeGenerator.AzureResourceExtension));
}
/// <summary>
/// Normalizes client model by updating names and types to be language specific.
/// </summary>
/// <param name="serviceClient"></param>
public override void NormalizeClientModel(ServiceClient serviceClient)
{
Extensions.NormalizeClientModel(serviceClient, Settings);
PopulateAdditionalProperties(serviceClient);
Namer.NormalizeClientModel(serviceClient);
Namer.ResolveNameCollisions(serviceClient, Settings.Namespace,
Settings.Namespace + ".Models");
Namer.NormalizeOdataFilterParameter(serviceClient);
}
public ServiceClientTemplateModel(ServiceClient serviceClient, bool internalConstructors)
{
this.LoadFrom(serviceClient);
MethodTemplateModels = new List<MethodTemplateModel>();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient)));
ConstructorVisibility = internalConstructors ? "internal" : "public";
this.IsCustomBaseUri = serviceClient.Extensions.ContainsKey(Microsoft.Rest.Generator.Extensions.ParameterizedHostExtension);
}
/// <summary>
/// Initializes a new instance
/// </summary>
/// <param name="serviceClient">The service client instance.</param>
/// <param name="methodGroupName">The name of the method group.</param>
public AzureMethodGroupTemplateModel(ServiceClient serviceClient, string methodGroupName)
: base(serviceClient, methodGroupName)
{
// Clear base initialized MethodTemplateModels and re-populate with
// AzureMethodTemplateModel
MethodTemplateModels.Clear();
Methods.Where(m => m.Group == methodGroupName)
.ForEach(m => MethodTemplateModels.Add(new AzureMethodTemplateModel(m, serviceClient)));
}
/// <summary>
/// Initializes a new instance of ServiceClientTemplateModel class.
/// </summary>
/// <param name="serviceClient"></param>
public ServiceClientTemplateModel(ServiceClient serviceClient)
{
this.LoadFrom(serviceClient);
HasModelTypes = serviceClient.HasModelTypes();
MethodTemplateModels = new List<MethodTemplateModel>();
Methods.Where(m => m.Group == null)
.ForEach(m => MethodTemplateModels.Add(new MethodTemplateModel(m, serviceClient)));
this.IsCustomBaseUri = serviceClient.Extensions.ContainsKey(Microsoft.Rest.Generator.Extensions.ParameterizedHostExtension);
}