public static void SaveToFile(XmlSerializationTemplate ob, string filename)
{
XmlSerializer serializer = new XmlSerializer(typeof(XmlSerializationTemplate));
TextWriter writer = new StreamWriter(filename);
serializer.Serialize(writer, ob);
writer.Close();
}
/// <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}"));
}
}
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}"));
}
}
public static void SaveToFile(XmlSerializationTemplate ob)
{
SaveToFile(ob, DefaultFilePath);
}
