/// <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"));
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="cm"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
// get c# specific codeModel
var codeModel = cm as CodeModelCs;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a c# CodeModel");
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate{ Model = codeModel };
await Write(serviceClientTemplate, $"{codeModel.Name}{ImplementationFileExtension}" );
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = codeModel };
await Write(serviceClientInterfaceTemplate, $"I{codeModel.Name}{ImplementationFileExtension}");
// operations
foreach (MethodGroupCs methodGroup in codeModel.Operations)
{
if(!methodGroup.Name.IsNullOrEmpty()) {
// Operation
var operationsTemplate = new MethodGroupTemplate { Model = methodGroup };
await Write(operationsTemplate, $"{operationsTemplate.Model.TypeName}{ImplementationFileExtension}");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = methodGroup };
await Write(operationsInterfaceTemplate, $"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}");
}
var operationExtensionsTemplate = new ExtensionsTemplate { Model = methodGroup };
await Write(operationExtensionsTemplate, $"{methodGroup.ExtensionTypeName}Extensions{ImplementationFileExtension}");
}
// Models
foreach (CompositeTypeCs model in codeModel.ModelTypes.Union(codeModel.HeaderTypes))
{
var modelTemplate = new ModelTemplate{ Model = model };
await Write(modelTemplate, Path.Combine(Settings.Instance.ModelsName, $"{model.Name}{ImplementationFileExtension}"));
}
// Enums
foreach (EnumTypeCs enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate { Model = enumType };
await Write(enumTemplate, Path.Combine(Settings.Instance.ModelsName, $"{enumTemplate.Model.Name}{ImplementationFileExtension}"));
}
// Exceptions
foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate { Model = exceptionType, };
await Write(exceptionTemplate, Path.Combine(Settings.Instance.ModelsName, $"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}"));
}
}
/// <summary>
/// Generate Java client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
// get Java specific codeModel
var codeModel = cm as CodeModelJv;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a Java CodeModel");
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, $"{Path.Combine("implementation", cm.Name.ToPascalCase() + "Impl")}{ImplementationFileExtension}");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate {
Model = codeModel
};
await Write(serviceClientInterfaceTemplate, $"{cm.Name.ToPascalCase()}{ImplementationFileExtension}");
// operations
foreach (MethodGroupJv methodGroup in codeModel.AllOperations)
{
// Operation
var operationsTemplate = new MethodGroupTemplate {
Model = methodGroup
};
await Write(operationsTemplate, $"{Path.Combine("implementation", methodGroup.TypeName.ToPascalCase())}Impl{ImplementationFileExtension}");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate {
Model = methodGroup
};
await Write(operationsInterfaceTemplate, $"{methodGroup.TypeName.ToPascalCase()}{ImplementationFileExtension}");
}
//Models
foreach (CompositeTypeJv modelType in cm.ModelTypes.Union(codeModel.HeaderTypes))
{
var modelTemplate = new ModelTemplate {
Model = modelType
};
await Write(modelTemplate, Path.Combine("models", $"{modelType.Name.ToPascalCase()}{ImplementationFileExtension}"));
}
// Enums
foreach (EnumTypeJv enumType in cm.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
await Write(enumTemplate, Path.Combine("models", $"{enumTemplate.Model.Name.ToPascalCase()}{ImplementationFileExtension}"));
}
// Exceptions
foreach (CompositeTypeJv exceptionType in codeModel.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate {
Model = exceptionType
};
await Write(exceptionTemplate, Path.Combine("models", $"{exceptionTemplate.Model.ExceptionTypeDefinitionName.ToPascalCase()}{ImplementationFileExtension}"));
}
// package-info.java
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(cm)
}, _packageInfoFileName);
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(cm, "implementation")
}, Path.Combine("implementation", _packageInfoFileName));
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(cm, "models")
}, Path.Combine("models", _packageInfoFileName));
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
var extensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, null),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, group),
};
await Write(operationExtensionsTemplate, operationExtensionsTemplate.Model.ExtensionName + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)model.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(model),
};
await Write(modelTemplate, Path.Combine("Models", model.Name + ".cs"));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine("Models", enumTemplate.Model.TypeDefinitionName + ".cs"));
}
// Page class
foreach (var pageClass in pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new PageTemplateModel(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value),
};
await Write(pageTemplate, Path.Combine("Models", pageTemplate.Model.TypeDefinitionName + ".cs"));
}
// Exceptions
foreach (var exceptionType in serviceClient.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType),
};
await Write(exceptionTemplate, Path.Combine("Models", exceptionTemplate.Model.ExceptionTypeDefinitionName + ".cs"));
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient, InternalConstructors),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
var extensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, null),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new ServiceClientTemplateModel(serviceClient, InternalConstructors),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, group),
};
await Write(operationExtensionsTemplate, group + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(model),
};
await Write(modelTemplate, Path.Combine("Models", model.Name + ".cs"));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine("Models", enumTemplate.Model.TypeDefinitionName + ".cs"));
}
// Exception
foreach (var exceptionType in serviceClient.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType),
};
await Write(exceptionTemplate, Path.Combine("Models", exceptionTemplate.Model.ExceptionTypeDefinitionName + ".cs"));
}
}
/// <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"));
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="codeModel"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelCsa;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a Azure c# CodeModel");
}
// Service client
var serviceClientTemplate = new AutoRest.CSharp.Azure.JsonRpcClient.Templates.AzureServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, $"{codeModel.Name}{ImplementationFileExtension}");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate {
Model = codeModel
};
await Write(serviceClientInterfaceTemplate, "I" + codeModel.Name + ImplementationFileExtension);
// Operations
foreach (MethodGroupCs group in codeModel.Operations)
{
if (!group.IsCodeModelMethodGroup)
{
// Operation
var operationsTemplate = new AutoRest.CSharp.Azure.JsonRpcClient.Templates.AzureMethodGroupTemplate {
Model = group
};
await Write(operationsTemplate, operationsTemplate.Model.TypeName + ImplementationFileExtension);
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate {
Model = group
};
await Write(operationsInterfaceTemplate,
$"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}");
}
var operationExtensionsTemplate = new ExtensionsTemplate {
Model = group
};
await Write(operationExtensionsTemplate,
$"{group.ExtensionTypeName}Extensions{ImplementationFileExtension}");
}
// Models
foreach (CompositeTypeCs model in codeModel.ModelTypes.Concat(codeModel.HeaderTypes))
{
if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)model.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate {
Model = model
};
await Write(modelTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{model.Name}{ImplementationFileExtension}"));
}
// Enums
foreach (EnumTypeCs enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
await Write(enumTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{enumTemplate.Model.Name}{ImplementationFileExtension}"));
}
// Page class
foreach (var pageClass in codeModel.pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new Page(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value)
};
await Write(pageTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{pageTemplate.Model.TypeDefinitionName}{ImplementationFileExtension}"));
}
// Exceptions
foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate {
Model = exceptionType
};
await Write(exceptionTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}"));
}
// Xml Serialization
if (codeModel.ShouldGenerateXmlSerialization)
{
var xmlSerializationTemplate = new XmlSerializationTemplate {
Model = null
};
await Write(xmlSerializationTemplate, Path.Combine(Settings.Instance.ModelsName, $"{XmlSerialization.XmlDeserializationClass}{ImplementationFileExtension}"));
}
}
/// <summary>
/// Generate Java client code for given ServiceClient.
/// </summary>
/// <param name="cm"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var packagePath = $"./{cm.Namespace.ToLower().Replace('.', '/')}";
// get ObjectiveC specific codeModel
if (!(cm is CodeModelOc codeModel))
{
throw new InvalidCastException("CodeModel is not a ObjectiveC CodeModel");
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, $"{packagePath}/{codeModel.ServiceClientServiceType/*.ToPascalCase()*/}{ImplementationFileExtension}");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate {
Model = codeModel
};
await Write(serviceClientInterfaceTemplate, $"{packagePath}/{codeModel.ServiceClientServiceType/*.ToPascalCase()*/}{InterfaceFileExtension}");
// UnitTests
var unitTestsTemplate = new UnitTestsTemplate {
Model = codeModel
};
await Write(unitTestsTemplate, $"{packagePath}/{codeModel.ServiceClientServiceType/*.ToPascalCase()*/}Tests{ImplementationFileExtension}");
// operations
foreach (var methodGroup in codeModel.AllOperations)
{
// Operation
var operationsTemplate = new MethodGroupTemplate {
Model = methodGroup
};
await Write(operationsTemplate, $"{packagePath}/Operations/{methodGroup.TypeName/*.ToPascalCase()*/}{ImplementationFileExtension}");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate {
Model = methodGroup
};
await Write(operationsInterfaceTemplate, $"{packagePath}/Operations/{methodGroup.TypeName/*.ToPascalCase()*/}{InterfaceFileExtension}");
}
//Models
foreach (CompositeTypeOc modelType in cm.ModelTypes.Union(codeModel.HeaderTypes))
{
//var cp = modelType.ComposedProperties; // combined whith base type props if any
var modelTemplate = new ModelTemplate {
Model = modelType
};
await Write(modelTemplate, $"{packagePath}/Models/{modelType.Name}{InterfaceFileExtension}");
var modelTemplateImpl = new ModelTemplateImpl {
Model = modelType
};
await Write(modelTemplateImpl, $"{packagePath}/Models/{modelType.Name}{ImplementationFileExtension}");
}
// Enums
foreach (EnumTypeOc enumType in cm.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
await Write(enumTemplate, $"{packagePath}/Models/{enumTemplate.Model.Name}{InterfaceFileExtension}");
var enumTemplateImpl = new EnumTemplateImpl {
Model = enumType
};
await Write(enumTemplateImpl, $"{packagePath}/Models/{enumTemplate.Model.Name}{ImplementationFileExtension}");
}
// package-info
// await Write(new PackageInfoTemplate
// {
// Model = new PackageInfoTemplateModel(cm)
// }, $"{packagePath}/{_packageInfoFileName}");
// await Write(new PackageInfoTemplate
// {
// Model = new PackageInfoTemplateModel(cm, "implementation")
// }, $"{packagePath}/implementation/{_packageInfoFileName}");
// await Write(new PackageInfoTemplate
// {
// Model = new PackageInfoTemplateModel(cm, "models")
// }, $"{packagePath}/models/{_packageInfoFileName}");
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
var extensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, null),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, group),
};
await Write(operationExtensionsTemplate, operationExtensionsTemplate.Model.ExtensionName + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
if (model.Extensions.ContainsKey(ExternalExtension) && (bool) model.Extensions[ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(model),
};
await Write(modelTemplate, Path.Combine("Models", model.Name + ".cs"));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine("Models", enumTemplate.Model.TypeDefinitionName + ".cs"));
}
}
private async Task GenerateClientSideCode(CodeModelCs codeModel)
{
CompositeTypeCs.DefaultPropertyTypeSelectionStrategy = new WrappedPropertyTypeSelectionStrategy();
var usings = new List <string>();
var methodGroups = codeModel.Operations.Cast <MethodGroupCs>();
var methods = codeModel.Methods.Where(m => m.Group.IsNullOrEmpty()).Cast <MethodCs>().ToList();
var project = new ProjectModel
{
RootNameSpace = codeModel.Namespace
};
var metricsTemplate = new MetricsTemplate {
Model = methods
};
var metricsFilePath = "Metrics.cs";
await Write(metricsTemplate, metricsFilePath);
var brokenRuleTemplate = new BrokenRuleTemplate();
var brokenRuleFilePath = "BrokenRule.cs";
await Write(brokenRuleTemplate, brokenRuleFilePath);
var responseTemplate = new ResponseTemplate();
var responseFilePath = "Response.cs";
await Write(responseTemplate, responseFilePath);
usings.AddRange(new[]
{
"System", "System.Collections.Generic", "System.Linq", "System.Threading",
"System.Threading.Tasks", "Microsoft.Rest", "System.IO",
"Microsoft.Rest.Serialization", "Agoda.RoundRobin", "Newtonsoft.Json",
$"{codeModel.Namespace}.Models", "Agoda.RoundRobin.Constants", "System.ComponentModel",
"AutoRest.CSharp.LoadBalanced.Json"
});
usings = usings.Where(u => !string.IsNullOrWhiteSpace(u)).Distinct().ToList();
codeModel.Usings = usings;
var clients = methods.GroupBy(m => m.Tags.First()).ToArray();
var libPath = Path.Combine(Settings.Instance.OutputDirectory, "lib");
await new LibFolderCreator(libPath).ExecuteAsync();
foreach (var client in clients)
{
var clientName = $"{client.Key.ToPascalCase()}Client";
var clientMethods = client.ToArray();
var clientClassFileName = $"{clientName}{ImplementationFileExtension}";
var clientInterfaceFileName = $"I{clientClassFileName}";
var model = new Tuple <CodeModelCs, string, MethodCs[]>(codeModel, clientName, clientMethods);
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate {
Model = model
};
await Write(serviceClientInterfaceTemplate, clientInterfaceFileName);
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = model
};
await Write(serviceClientTemplate, clientClassFileName);
}
var apiBaseTemplate = new ApiBaseTemplate {
Model = codeModel
};
var apiBaseCsPath = "ApiBase.cs";
await Write(apiBaseTemplate, apiBaseCsPath);
var badRequestExceptionTemplate = new BadRequestExceptionTemplate();
var badRequestPath = "BadRequestException.cs";
await Write(badRequestExceptionTemplate, badRequestPath);
// operations
foreach (var methodGroup in methodGroups)
{
if (methodGroup.Name.IsNullOrEmpty())
{
continue;
}
// Operation
var operationsTemplate = new MethodGroupTemplate {
Model = methodGroup
};
var operationsFilePath = $"{operationsTemplate.Model.TypeName}{ImplementationFileExtension}";
await Write(operationsTemplate, operationsFilePath);
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate {
Model = methodGroup
};
var operationsInterfacePath =
$"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}";
await Write(operationsInterfaceTemplate, operationsInterfacePath);
}
// Models
var models = codeModel.ModelTypes.Union(codeModel.HeaderTypes).Cast <CompositeTypeCs>();
foreach (var model in models)
{
if (model.Extensions.ContainsKey(SwaggerExtensions.ExternalExtension) &&
(bool)model.Extensions[SwaggerExtensions.ExternalExtension])
{
continue;
}
Template <CompositeTypeCs> modelTemplate = null;
if (model.PropertyTypeSelectionStrategy.IsCollection(model))
{
modelTemplate = new CollectionModelTemplate {
Model = model
};
}
else
{
modelTemplate = new ModelTemplate {
Model = model
};
}
var modelPath = Path.Combine(Settings.Instance.ModelsName, $"{model.Name}{ImplementationFileExtension}");
await Write(modelTemplate, modelPath);
}
// Enums
foreach (EnumTypeCs enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
var enumFilePath = Path.Combine(Settings.Instance.ModelsName, $"{enumTemplate.Model.Name}{ImplementationFileExtension}");
await Write(enumTemplate, enumFilePath);
}
// Exceptions
foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate {
Model = exceptionType,
};
var exceptionFilePath =
Path.Combine(Settings.Instance.ModelsName, $"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}");
await Write(exceptionTemplate, exceptionFilePath);
}
// CB models
var couchbaseModels = codeModel.ModelTypes.Union(codeModel.HeaderTypes).Cast <CompositeTypeCs>();
foreach (var model in couchbaseModels)
{
model.isCouchbaseModel = true;
if (model.Extensions.ContainsKey(SwaggerExtensions.ExternalExtension) &&
(bool)model.Extensions[SwaggerExtensions.ExternalExtension])
{
continue;
}
Template <CompositeTypeCs> modelTemplate = null;
if (model.PropertyTypeSelectionStrategy.IsCollection(model))
{
modelTemplate = new CollectionModelTemplate {
Model = model
};
}
else
{
modelTemplate = new ModelTemplate {
Model = model
};
}
var modelPath = Path.Combine(Settings.Instance.ModelsName, $"Couchbase/{model.Name}{ImplementationFileExtension}");
project.FilePaths.Add(modelPath);
await Write(modelTemplate, modelPath);
}
}
/// <summary>
/// Generate Java client code for given ServiceClient.
/// </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
foreach (var modelType in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(modelType, serviceClient)
};
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"));
}
// Exception
foreach (var exceptionType in serviceClient.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType, serviceClient),
};
await Write(exceptionTemplate, Path.Combine("models", exceptionTemplate.Model.ExceptionTypeDefinitionName.ToPascalCase() + ".java"));
}
// package-info.java
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name)
}, _packageInfoFileName);
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name, true)
}, Path.Combine("models", _packageInfoFileName));
}
private async Task GenerateClientSideCode(CodeModelCs codeModel)
{
CompositeTypeCs.DefaultPropertyTypeSelectionStrategy = new PropertyTypeSelectionStrategy();
var usings = new List <string>(codeModel.Usings);
var methods = codeModel.Methods.Where(m => m.Group.IsNullOrEmpty()).Cast <MethodCs>().ToList();
var project = new ProjectModel
{
RootNameSpace = codeModel.Namespace
};
var metricsTemplate = new MetricsTemplate {
Model = methods
};
var metricsFilePath = "Metrics.cs";
project.FilePaths.Add(metricsFilePath);
await Write(metricsTemplate, metricsFilePath);
var responseTemplate = new ResponseTemplate();
var responseFilePath = "Response.cs";
project.FilePaths.Add(responseFilePath);
await Write(responseTemplate, responseFilePath);
usings.Add("System");
usings.Add("System.Collections.Generic");
usings.Add("System.Linq");
usings.Add("System.Threading");
usings.Add("System.Threading.Tasks");
usings.Add("Microsoft.Rest");
usings.Add("System.IO");
usings.Add("Microsoft.Rest.Serialization");
usings.Add("System.Net.Http");
usings.Add("Agoda.Frameworks.Http");
usings.Add("Agoda.Frameworks.Http.AutoRestExt");
usings.Add("Newtonsoft.Json");
usings.Add($"{codeModel.Namespace}.Models");
codeModel.Usings = usings.Where(u => !string.IsNullOrWhiteSpace(u)).Distinct();
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
var clientPath = $"{codeModel.Name}{ImplementationFileExtension}";
project.FilePaths.Add(clientPath);
await Write(serviceClientTemplate, clientPath);
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate {
Model = codeModel
};
var interfacePath = $"I{codeModel.Name}{ImplementationFileExtension}";
project.FilePaths.Add(interfacePath);
await Write(serviceClientInterfaceTemplate, interfacePath);
var apiBaseTemplate = new ApiBaseTemplate {
Model = codeModel
};
var apiBaseCsPath = "ApiBase.cs";
project.FilePaths.Add(apiBaseCsPath);
await Write(apiBaseTemplate, apiBaseCsPath);
// operations
foreach (var methodGroup1 in codeModel.Operations)
{
var methodGroup = (MethodGroupCs)methodGroup1;
if (!methodGroup.Name.IsNullOrEmpty())
{
// Operation
var operationsTemplate = new MethodGroupTemplate {
Model = methodGroup
};
var operationsFilePath = $"{operationsTemplate.Model.TypeName}{ImplementationFileExtension}";
project.FilePaths.Add(operationsFilePath);
await Write(operationsTemplate, operationsFilePath);
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate {
Model = methodGroup
};
var operationsInterfacePath =
$"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}";
project.FilePaths.Add(operationsInterfacePath);
await Write(operationsInterfaceTemplate, operationsInterfacePath);
}
}
// Models
foreach (CompositeTypeCs model in codeModel.ModelTypes.Union(codeModel.HeaderTypes))
{
if (model.Extensions.ContainsKey(SwaggerExtensions.ExternalExtension) &&
(bool)model.Extensions[SwaggerExtensions.ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate {
Model = model
};
var modelPath = Path.Combine(Settings.Instance.ModelsName, $"{model.Name}{ImplementationFileExtension}");
project.FilePaths.Add(modelPath);
await Write(modelTemplate, modelPath);
}
// Enums
foreach (EnumTypeCs enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
var enumFilePath = Path.Combine(Settings.Instance.ModelsName, $"{enumTemplate.Model.Name}{ImplementationFileExtension}");
project.FilePaths.Add(enumFilePath);
await Write(enumTemplate, enumFilePath);
}
// Exceptions
foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate {
Model = exceptionType,
};
var exceptionFilePath =
Path.Combine(Settings.Instance.ModelsName, $"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}");
project.FilePaths.Add(exceptionFilePath);
await Write(exceptionTemplate, exceptionFilePath);
}
// Xml Serialization
if (codeModel.ShouldGenerateXmlSerialization)
{
var xmlSerializationTemplate = new XmlSerializationTemplate();
var xmlSerializationPath = Path.Combine(Settings.Instance.ModelsName,
$"{XmlSerialization.XmlDeserializationClass}{ImplementationFileExtension}");
project.FilePaths.Add(xmlSerializationPath);
await Write(xmlSerializationTemplate, xmlSerializationPath);
}
}
protected virtual async Task GenerateClientSideCode(CodeModelCs codeModel)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, $"{codeModel.Name}{ImplementationFileExtension}");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate {
Model = codeModel
};
await Write(serviceClientInterfaceTemplate, $"I{codeModel.Name}{ImplementationFileExtension}");
// operations
foreach (MethodGroupCs methodGroup in codeModel.Operations)
{
if (!methodGroup.Name.IsNullOrEmpty())
{
// Operation
var operationsTemplate = new MethodGroupTemplate {
Model = methodGroup
};
await Write(operationsTemplate, $"{operationsTemplate.Model.TypeName}{ImplementationFileExtension}");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate {
Model = methodGroup
};
await Write(operationsInterfaceTemplate, $"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}");
}
var operationExtensionsTemplate = new ExtensionsTemplate {
Model = methodGroup
};
await Write(operationExtensionsTemplate, $"{methodGroup.ExtensionTypeName}Extensions{ImplementationFileExtension}");
}
// Models
foreach (CompositeTypeCs model in codeModel.ModelTypes.Union(codeModel.HeaderTypes))
{
if (model.Extensions.ContainsKey(SwaggerExtensions.ExternalExtension) &&
(bool)model.Extensions[SwaggerExtensions.ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate {
Model = model
};
await Write(modelTemplate, Path.Combine(Settings.Instance.ModelsName, $"{model.Name}{ImplementationFileExtension}"));
}
// Enums
foreach (EnumTypeCs enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
await Write(enumTemplate, Path.Combine(Settings.Instance.ModelsName, $"{enumTemplate.Model.Name}{ImplementationFileExtension}"));
}
// Exceptions
foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate {
Model = exceptionType,
};
await Write(exceptionTemplate, Path.Combine(Settings.Instance.ModelsName, $"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}"));
}
// Xml Serialization
if (codeModel.ShouldGenerateXmlSerialization)
{
var xmlSerializationTemplate = new XmlSerializationTemplate();
await Write(xmlSerializationTemplate, Path.Combine(Settings.Instance.ModelsName, $"{XmlSerialization.XmlDeserializationClass}{ImplementationFileExtension}"));
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="cm"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
// get c# specific codeModel
var codeModel = cm as CodeModelCs;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a c# CodeModel");
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, $"{codeModel.Name}{ImplementationFileExtension}");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate {
Model = codeModel
};
await Write(serviceClientInterfaceTemplate, $"I{codeModel.Name}{ImplementationFileExtension}");
// operations
foreach (MethodGroupCs methodGroup in codeModel.Operations)
{
if (!methodGroup.Name.IsNullOrEmpty())
{
// Operation
var operationsTemplate = new MethodGroupTemplate {
Model = methodGroup
};
await Write(operationsTemplate, $"{operationsTemplate.Model.TypeName}{ImplementationFileExtension}");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate {
Model = methodGroup
};
await Write(operationsInterfaceTemplate, $"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}");
}
var operationExtensionsTemplate = new ExtensionsTemplate {
Model = methodGroup
};
await Write(operationExtensionsTemplate, $"{methodGroup.ExtensionTypeName}Extensions{ImplementationFileExtension}");
}
// Models
foreach (CompositeTypeCs model in codeModel.ModelTypes.Union(codeModel.HeaderTypes))
{
var modelTemplate = new ModelTemplate {
Model = model
};
await Write(modelTemplate, Path.Combine(Settings.Instance.ModelsName, $"{model.Name}{ImplementationFileExtension}"));
}
// Enums
foreach (EnumTypeCs enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
await Write(enumTemplate, Path.Combine(Settings.Instance.ModelsName, $"{enumTemplate.Model.Name}{ImplementationFileExtension}"));
}
// Exceptions
foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate {
Model = exceptionType,
};
await Write(exceptionTemplate, Path.Combine(Settings.Instance.ModelsName, $"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}"));
}
}
/// <summary>
/// Generate Java client code for given ServiceClient.
/// </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
foreach (var modelType in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(modelType, serviceClient)
};
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"));
}
// Exception
foreach (var exceptionType in serviceClient.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType, serviceClient),
};
await Write(exceptionTemplate, Path.Combine("models", exceptionTemplate.Model.ExceptionTypeDefinitionName.ToPascalCase() + ".java"));
}
// package-info.java
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name)
}, _packageInfoFileName);
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name, true)
}, Path.Combine("models", _packageInfoFileName));
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient, InternalConstructors),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
if (serviceClient.Methods.Any(m => m.Group == null))
{
var extensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, null, SyncMethods),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
}
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new ServiceClientTemplateModel(serviceClient, InternalConstructors),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, group, SyncMethods),
};
await Write(operationExtensionsTemplate, group + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(model),
};
await Write(modelTemplate, Path.Combine(Settings.ModelsName, model.Name + ".cs"));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine(Settings.ModelsName, enumTemplate.Model.TypeDefinitionName + ".cs"));
}
// Exception
foreach (var exceptionType in serviceClient.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType),
};
await Write(exceptionTemplate, Path.Combine(Settings.ModelsName, exceptionTemplate.Model.ExceptionTypeDefinitionName + ".cs"));
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
var extensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, null),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new ServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, group),
};
await Write(operationExtensionsTemplate, group + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(model),
};
await Write(modelTemplate, "Models\\" + model.Name + ".cs");
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, "Models\\" + enumTemplate.Model.TypeDefinitionName + ".cs");
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="cm"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelCsa;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a Azure c# CodeModel");
}
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel };
await Write(serviceClientTemplate, $"{codeModel.Name}{ImplementationFileExtension}");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = codeModel };
await Write(serviceClientInterfaceTemplate, "I" + codeModel.Name + ImplementationFileExtension);
// Operations
foreach (MethodGroupCs group in codeModel.Operations)
{
if (!group.IsCodeModelMethodGroup)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate { Model = group };
await Write(operationsTemplate, operationsTemplate.Model.TypeName + ImplementationFileExtension);
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = group };
await Write(operationsInterfaceTemplate,
$"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}");
}
var operationExtensionsTemplate = new ExtensionsTemplate { Model = group };
await Write(operationExtensionsTemplate,
$"{group.ExtensionTypeName}Extensions{ImplementationFileExtension}");
}
// Models
foreach (CompositeTypeCs model in codeModel.ModelTypes.Concat(codeModel.HeaderTypes))
{
if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)model.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
if (model.IsResource())
{
continue;
}
var modelTemplate = new ModelTemplate { Model = model };
await Write(modelTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{model.Name}{ImplementationFileExtension}"));
}
// Enums
foreach (EnumTypeCs enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate { Model = enumType };
await Write(enumTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{enumTemplate.Model.Name}{ImplementationFileExtension}"));
}
// Page class
foreach (var pageClass in codeModel.pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new Page(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value)
};
await Write(pageTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{pageTemplate.Model.TypeDefinitionName}{ImplementationFileExtension}"));
}
// Exceptions
foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate { Model = exceptionType };
await Write(exceptionTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}"));
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient, InternalConstructors),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
if (serviceClient.Methods.Any(m => m.Group == null))
{
var extensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, null, SyncMethods),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
}
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient, InternalConstructors),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, group, SyncMethods),
};
await Write(operationExtensionsTemplate, operationExtensionsTemplate.Model.ExtensionName + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool) model.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(model),
};
await Write(modelTemplate, Path.Combine(Settings.ModelsName, model.Name + ".cs"));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine(Settings.ModelsName, enumTemplate.Model.TypeDefinitionName + ".cs"));
}
// Page class
foreach (var pageClass in pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new PageTemplateModel(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value),
};
await Write(pageTemplate, Path.Combine(Settings.ModelsName, pageTemplate.Model.TypeDefinitionName + ".cs"));
}
// Exceptions
foreach (var exceptionType in serviceClient.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType),
};
await Write(exceptionTemplate, Path.Combine(Settings.ModelsName, exceptionTemplate.Model.ExceptionTypeDefinitionName + ".cs"));
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
var extensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, null),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, group),
};
await Write(operationExtensionsTemplate, operationExtensionsTemplate.Model.ExtensionName + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
if (model.Extensions.ContainsKey(ExternalExtension) && (bool)model.Extensions[ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(model),
};
await Write(modelTemplate, Path.Combine("Models", model.Name + ".cs"));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine("Models", enumTemplate.Model.TypeDefinitionName + ".cs"));
}
}
