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