/// <summary>
/// Generates Go code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
string packageName = GoCodeNamer.PackageNameFromNamespace(Settings.Namespace);
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient, packageName),
};
await Write(serviceClientTemplate, GoCodeNamer.FormatFileName("client"));
foreach (var methodGroupName in serviceClient.MethodGroups)
{
var groupedMethodTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, packageName, methodGroupName),
};
await Write(groupedMethodTemplate, GoCodeNamer.FormatFileName(methodGroupName.ToLowerInvariant()));
}
// Models
var modelsTemplate = new ModelsTemplate
{
Model = new ModelsTemplateModel(serviceClient, packageName),
};
await Write(modelsTemplate, GoCodeNamer.FormatFileName("models"));
// Version
var versionTemplate = new VersionTemplate
{
Model = new VersionTemplateModel(serviceClient, packageName),
};
await Write(versionTemplate, GoCodeNamer.FormatFileName("version"));
}
/// <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 Go code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelGo;
if (codeModel == null)
{
throw new Exception("Code model is not a Go Code Model");
}
// unfortunately there is an ordering issue here. during model generation we might
// flatten some types (but not all depending on type). then during client generation
// the validation codegen needs to know if a type was flattened so it can generate
// the correct code, so we need to generate models before clients.
// Models
var modelsTemplate = new ModelsTemplate
{
Model = codeModel
};
await Write(modelsTemplate, FormatFileName("models"));
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = codeModel
};
await Write(serviceClientTemplate, FormatFileName("client"));
// by convention the methods in the method group with an empty
// name go into the client template so skip them here.
HashSet <string> ReservedFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase)
{
"models",
"client",
"version",
};
foreach (var methodGroup in codeModel.MethodGroups.Where(mg => !string.IsNullOrEmpty(mg.Name)))
{
if (ReservedFiles.Contains(methodGroup.Name.Value))
{
methodGroup.Name += "group";
}
ReservedFiles.Add(methodGroup.Name);
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroup
};
await Write(methodGroupTemplate, FormatFileName(methodGroup.Name).ToLowerInvariant());
}
// Version
var versionTemplate = new VersionTemplate {
Model = codeModel
};
await Write(versionTemplate, FormatFileName("version"));
}
/// <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>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient">The service client.</param>
/// <returns>Async task for generating SDK files.</returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate,
Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension));
// Method groups
foreach (var group in serviceClient.MethodGroups)
{
var groupTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(groupTemplate,
Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(group) + ImplementationFileExtension));
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(model, serviceClient.ModelTypes)
};
await Write(modelTemplate,
Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate,
Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension));
}
// Requirements
var requirementsTemplate = new RequirementsTemplate
{
Model = new RequirementsTemplateModel(serviceClient, sdkName, this.ImplementationFileExtension),
};
await Write(requirementsTemplate,
RubyCodeNamer.UnderscoreCase(sdkName) + ImplementationFileExtension);
}
/// <summary>
/// Generate NodeJS 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.ToCamelCase() + ".js");
//Models
if (serviceClient.ModelTypes.Any())
{
var modelIndexTemplate = new ModelIndexTemplate
{
Model = serviceClientTemplateModel
};
await Write(modelIndexTemplate, Path.Combine("models", "index.js"));
foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine("models", modelType.Name.ToCamelCase() + ".js"));
}
}
//MethodGroups
if (serviceClientTemplateModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupIndexTemplate
{
Model = serviceClientTemplateModel
};
await Write(methodGroupIndexTemplate, Path.Combine("operations", "index.js"));
foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine("operations", methodGroupModel.MethodGroupType.ToCamelCase() + ".js"));
}
}
}
/// <summary>
/// Generates Go code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
string packageName = GoCodeNamer.PackageNameFromNamespace(Settings.Namespace);
// If version is passed in command line then pick that, else keep it 0.0.0(to make it optional for testing).
string[] version = GoCodeNamer.SDKVersionFromPackageVersion(
!string.IsNullOrEmpty(Settings.PackageVersion)
? Settings.PackageVersion
: "0.0.0");
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient, packageName),
};
await Write(serviceClientTemplate, GoCodeNamer.FormatFileName("client"));
foreach (var methodGroupName in serviceClient.MethodGroups)
{
var groupedMethodTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, packageName, methodGroupName),
};
await Write(groupedMethodTemplate, GoCodeNamer.FormatFileName(methodGroupName.ToLowerInvariant()));
}
// Models
var modelsTemplate = new ModelsTemplate
{
Model = new ModelsTemplateModel(serviceClient, packageName),
};
await Write(modelsTemplate, GoCodeNamer.FormatFileName("models"));
// Version
var versionTemplate = new VersionTemplate
{
Model = new VersionTemplateModel(serviceClient, packageName, version),
};
await Write(versionTemplate, GoCodeNamer.FormatFileName("version"));
}
/// <summary>
/// Generates Go code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
string packageName = GoCodeNamer.PackageNameFromNamespace(Settings.Namespace);
// If version is passed in command line then pick that, else keep it 0.0.0(to make it optional for testing).
string[] version = GoCodeNamer.SDKVersionFromPackageVersion(
!string.IsNullOrEmpty(Settings.PackageVersion)
? Settings.PackageVersion
: "0.0.0");
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient, packageName),
};
await Write(serviceClientTemplate, GoCodeNamer.FormatFileName("client"));
foreach (var methodGroupName in serviceClient.MethodGroups)
{
var groupedMethodTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, packageName, methodGroupName),
};
await Write(groupedMethodTemplate, GoCodeNamer.FormatFileName(methodGroupName.ToLowerInvariant()));
}
// Models
var modelsTemplate = new ModelsTemplate
{
Model = new ModelsTemplateModel(serviceClient, packageName),
};
await Write(modelsTemplate, GoCodeNamer.FormatFileName("models"));
// Version
var versionTemplate = new VersionTemplate
{
Model = new VersionTemplateModel(serviceClient, packageName, version),
};
await Write(versionTemplate, GoCodeNamer.FormatFileName("version"));
}
/// <summary>
/// Generates Go code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
string packageName = GoCodeNamer.PackageNameFromNamespace(Settings.Namespace);
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient, packageName),
};
await Write(serviceClientTemplate, GoCodeNamer.FormatFileName("client"));
foreach (var methodGroupName in serviceClient.MethodGroups)
{
var groupedMethodTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, packageName, methodGroupName),
};
await Write(groupedMethodTemplate, GoCodeNamer.FormatFileName(methodGroupName.ToLowerInvariant()));
}
// Models
var modelsTemplate = new ModelsTemplate
{
Model = new ModelsTemplateModel(serviceClient, packageName),
};
await Write(modelsTemplate, GoCodeNamer.FormatFileName("models"));
// Version
var versionTemplate = new VersionTemplate
{
Model = new VersionTemplateModel(serviceClient, packageName),
};
await Write(versionTemplate, GoCodeNamer.FormatFileName("version"));
}
/// <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 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>
/// 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>
/// 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 Ruby code for service client.
/// </summary>
/// <param name="serviceClient">The service client.</param>
/// <returns>Async task for generating SDK files.</returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate,
Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension));
// Method groups
foreach (var group in serviceClient.MethodGroups)
{
var groupTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(groupTemplate,
Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(group) + ImplementationFileExtension));
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(model, serviceClient.ModelTypes)
};
await Write(modelTemplate,
Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate,
Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension));
}
// Requirements
var requirementsTemplate = new RequirementsTemplate
{
Model = new RequirementsTemplateModel(serviceClient, this.packageName ?? this.sdkName, this.ImplementationFileExtension, this.Settings.Namespace),
};
await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(this.packageName ?? this.sdkName) + ImplementationFileExtension);
// Version File
if (!string.IsNullOrEmpty(this.packageVersion))
{
var versionTemplate = new VersionTemplate
{
Model = new VersionTemplateModel(packageVersion),
};
await Write(versionTemplate, Path.Combine(sdkPath, "version" + ImplementationFileExtension));
}
// Module Definition File
if (!string.IsNullOrEmpty(Settings.Namespace))
{
var modTemplate = new ModuleDefinitionTemplate
{
Model = new ModuleDefinitionTemplateModel(Settings.Namespace),
};
await Write(modTemplate, Path.Combine(sdkPath, "module_definition" + ImplementationFileExtension));
}
}
/// <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>
/// Generate NodeJS 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.ToCamelCase() + ".js");
if (!DisableTypeScriptGeneration)
{
var serviceClientTemplateTS = new ServiceClientTemplateTS
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientTemplateTS, serviceClient.Name.ToCamelCase() + ".d.ts");
}
//Models
if (serviceClient.ModelTypes.Any())
{
var modelIndexTemplate = new ModelIndexTemplate
{
Model = serviceClientTemplateModel
};
await Write(modelIndexTemplate, Path.Combine("models", "index.js"));
if (!DisableTypeScriptGeneration)
{
var modelIndexTemplateTS = new ModelIndexTemplateTS
{
Model = serviceClientTemplateModel
};
await Write(modelIndexTemplateTS, Path.Combine("models", "index.d.ts"));
}
foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine("models", modelType.Name.ToCamelCase() + ".js"));
}
}
//MethodGroups
if (serviceClientTemplateModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupIndexTemplate
{
Model = serviceClientTemplateModel
};
await Write(methodGroupIndexTemplate, Path.Combine("operations", "index.js"));
if (!DisableTypeScriptGeneration)
{
var methodGroupIndexTemplateTS = new MethodGroupIndexTemplateTS
{
Model = serviceClientTemplateModel
};
await Write(methodGroupIndexTemplateTS, Path.Combine("operations", "index.d.ts"));
}
foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine("operations", methodGroupModel.MethodGroupType.ToCamelCase() + ".js"));
}
}
}
/// <summary>
/// Generate Python client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelPy;
if (codeModel == null)
{
throw new Exception("Code model is not a Python Code Model");
}
// Service client
var setupTemplate = new SetupTemplate {
Model = codeModel
};
await Write(setupTemplate, "setup.py");
var serviceClientInitTemplate = new ServiceClientInitTemplate {
Model = codeModel
};
await Write(serviceClientInitTemplate, Path.Combine(codeModel.PackageName, "__init__.py"));
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, Path.Combine(codeModel.PackageName, codeModel.Name.ToPythonCase() + ".py"));
var versionTemplate = new VersionTemplate {
Model = codeModel
};
await Write(versionTemplate, Path.Combine(codeModel.PackageName, "version.py"));
var exceptionTemplate = new ExceptionTemplate {
Model = codeModel
};
await Write(exceptionTemplate, Path.Combine(codeModel.PackageName, "exceptions.py"));
var credentialTemplate = new CredentialTemplate {
Model = codeModel
};
await Write(credentialTemplate, Path.Combine(codeModel.PackageName, "credentials.py"));
//Models
if (codeModel.ModelTypes.Any())
{
var modelInitTemplate = new ModelInitTemplate {
Model = codeModel
};
await Write(modelInitTemplate, Path.Combine(codeModel.PackageName, "models", "__init__.py"));
foreach (var modelType in codeModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine(codeModel.PackageName, "models", ((string)modelType.Name).ToPythonCase() + ".py"));
}
}
//MethodGroups
if (codeModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupInitTemplate
{
Model = codeModel
};
await Write(methodGroupIndexTemplate, Path.Combine(codeModel.PackageName, "operations", "__init__.py"));
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine(codeModel.PackageName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py"));
}
}
// Enums
if (codeModel.EnumTypes.Any())
{
var enumTemplate = new EnumTemplate {
Model = codeModel.EnumTypes
};
await Write(enumTemplate, Path.Combine(codeModel.PackageName, "models", codeModel.Name.ToPythonCase() + "_enums.py"));
}
}
/// <summary>
/// Generate NodeJS client code
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var disableTypeScriptGeneration = Singleton <GeneratorSettingsJs> .Instance.DisableTypeScriptGeneration;
var codeModel = cm as CodeModelJs;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a NodeJS code model.");
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, codeModel.Name.ToCamelCase() + ".js");
if (!disableTypeScriptGeneration)
{
var serviceClientTemplateTS = new ServiceClientTemplateTS {
Model = codeModel
};
await Write(serviceClientTemplateTS, codeModel.Name.ToCamelCase() + ".d.ts");
}
//Models
if (codeModel.ModelTypes.Any())
{
var modelIndexTemplate = new ModelIndexTemplate {
Model = codeModel
};
await Write(modelIndexTemplate, Path.Combine("models", "index.js"));
if (!disableTypeScriptGeneration)
{
var modelIndexTemplateTS = new ModelIndexTemplateTS {
Model = codeModel
};
await Write(modelIndexTemplateTS, Path.Combine("models", "index.d.ts"));
}
foreach (var modelType in codeModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate {
Model = modelType
};
await Write(modelTemplate, Path.Combine("models", modelType.NameAsFileName.ToCamelCase() + ".js"));
}
}
//MethodGroups
if (codeModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupIndexTemplate {
Model = codeModel
};
await Write(methodGroupIndexTemplate, Path.Combine("operations", "index.js"));
if (!disableTypeScriptGeneration)
{
var methodGroupIndexTemplateTS = new MethodGroupIndexTemplateTS {
Model = codeModel
};
await Write(methodGroupIndexTemplateTS, Path.Combine("operations", "index.d.ts"));
}
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate {
Model = methodGroupModel
};
await
Write(methodGroupTemplate,
Path.Combine("operations", methodGroupModel.TypeName.ToCamelCase() + ".js"));
}
}
}
/// <summary>
/// Generate TypeScript client code
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelTS;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a TypeScript code model.");
}
codeModel.PackageName = Settings.Instance.PackageName;
codeModel.PackageVersion = Settings.Instance.PackageVersion;
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, codeModel.Name.ToCamelCase() + ".ts");
await Write(new ServiceClientContextTemplate { Model = codeModel }, codeModel.ContextName.ToCamelCase() + ".ts");
//Models
if (codeModel.ModelTypes.Any())
{
var modelIndexTemplate = new ModelIndexTemplate {
Model = codeModel
};
await Write(modelIndexTemplate, Path.Combine("models", "index.ts"));
var mapperIndexTemplate = new MapperIndexTemplate {
Model = codeModel
};
await Write(mapperIndexTemplate, Path.Combine("models", "mappers.ts"));
}
//MethodGroups
if (codeModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupIndexTemplate {
Model = codeModel
};
await Write(methodGroupIndexTemplate, Path.Combine("operations", "index.ts"));
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate {
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine("operations", methodGroupModel.TypeName.ToCamelCase() + ".ts"));
}
}
var generateMetadata = Singleton <GeneratorSettingsTS> .Instance.GenerateMetadata;
if (generateMetadata)
{
// package.json
var packageJson = new PackageJson {
Model = codeModel
};
await Write(packageJson, Path.Combine("../", "package.json"));
//tsconfig.json
var nodeTsConfig = new TsConfig {
Model = new TsConfigModel(false)
};
await Write(nodeTsConfig, Path.Combine("../", "tsconfig.json"));
// webpack.config.js
var webpackConfig = new WebpackConfig {
Model = codeModel
};
await Write(webpackConfig, Path.Combine("../", "webpack.config.js"));
// .npmignore
var npmIgnore = new NpmIgnore {
Model = codeModel
};
await Write(npmIgnore, Path.Combine("../", ".npmignore"));
//README.md
var readme = new ReadmeTemplate {
Model = codeModel
};
await Write(readme, Path.Combine("../", "README.md"));
}
}
/// <summary>
/// Generate Python client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelPy;
if (codeModel == null)
{
throw new Exception("Code model is not a Python Code Model");
}
writeNamespaceFolders(codeModel);
if (codeModel.BasicSetupPy)
{
var setupTemplate = new SetupTemplate {
Model = codeModel
};
await Write(setupTemplate, "setup.py");
}
var folderName = codeModel.NoNamespaceFolders?"":Path.Combine(codeModel.Namespace.Split('.'));
var serviceClientInitTemplate = new ServiceClientInitTemplate {
Model = codeModel
};
await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py"));
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, Path.Combine(folderName, codeModel.Name.ToPythonCase() + ".py"));
// do we need to write out the version template file?
var versionPath = Path.Combine(folderName, "version.py");
// protect the version file
await Settings.Instance.Host.ProtectFiles(versionPath);
if (true != await Settings.Instance.Host.GetValue <bool?>("keep-version-file") || string.IsNullOrEmpty(await Settings.Instance.Host.ReadFile(versionPath)))
{
var versionTemplate = new VersionTemplate {
Model = codeModel
};
// if they didn't say to keep the old file (or it was not there/empty), write it out.
await Write(versionTemplate, versionPath);
}
//Models
if (codeModel.ModelTypes.Any())
{
var modelInitTemplate = new ModelInitTemplate {
Model = codeModel
};
await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py"));
foreach (var modelType in codeModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine(folderName, "models", ((string)modelType.Name).ToPythonCase() + ".py"));
// Rebuild the same in Python 3 mode
modelTemplate.Python3Mode = true;
await Write(modelTemplate, Path.Combine(folderName, "models", ((string)modelType.Name).ToPythonCase() + "_py3.py"));
}
}
//MethodGroups
if (codeModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupInitTemplate
{
Model = codeModel
};
await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py"));
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine(folderName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py"));
}
}
// Enums
if (codeModel.EnumTypes.Any())
{
var enumTemplate = new EnumTemplate {
Model = codeModel.EnumTypes
};
await Write(enumTemplate, Path.Combine(folderName, "models", codeModel.Name.ToPythonCase() + "_enums.py"));
}
}
/// <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 Python client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelPy;
if (codeModel == null)
{
throw new Exception("Code model is not a Python Code Model");
}
// Service client
var setupTemplate = new SetupTemplate { Model = codeModel };
await Write(setupTemplate, "setup.py");
var serviceClientInitTemplate = new ServiceClientInitTemplate { Model = codeModel };
await Write(serviceClientInitTemplate, Path.Combine(codeModel.PackageName, "__init__.py"));
var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel };
await Write(serviceClientTemplate, Path.Combine(codeModel.PackageName, codeModel.Name.ToPythonCase() + ".py"));
var versionTemplate = new VersionTemplate { Model = codeModel };
await Write(versionTemplate, Path.Combine(codeModel.PackageName, "version.py"));
var exceptionTemplate = new ExceptionTemplate { Model = codeModel };
await Write(exceptionTemplate, Path.Combine(codeModel.PackageName, "exceptions.py"));
var credentialTemplate = new CredentialTemplate { Model = codeModel };
await Write(credentialTemplate, Path.Combine(codeModel.PackageName, "credentials.py"));
//Models
if (codeModel.ModelTypes.Any())
{
var modelInitTemplate = new ModelInitTemplate { Model = codeModel };
await Write(modelInitTemplate, Path.Combine(codeModel.PackageName, "models", "__init__.py"));
foreach (var modelType in codeModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine(codeModel.PackageName, "models", ((string)modelType.Name).ToPythonCase() + ".py"));
}
}
//MethodGroups
if (codeModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupInitTemplate
{
Model = codeModel
};
await Write(methodGroupIndexTemplate, Path.Combine(codeModel.PackageName, "operations", "__init__.py"));
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine(codeModel.PackageName, "operations", ((string) methodGroupModel.TypeName).ToPythonCase() + ".py"));
}
}
// Enums
if (codeModel.EnumTypes.Any())
{
var enumTemplate = new EnumTemplate { Model = codeModel.EnumTypes };
await Write(enumTemplate, Path.Combine(codeModel.PackageName, "models", codeModel.Name.ToPythonCase() + "_enums.py"));
}
}
/// <summary>
/// Generate TypeScript client code
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelTS;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a TypeScript code model.");
}
InitializeSettings(codeModel);
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, codeModel.Name.ToCamelCase() + ".ts");
await Write(new ServiceClientContextTemplate { Model = codeModel }, codeModel.ContextName.ToCamelCase() + ".ts");
//Models
if (codeModel.ModelTypes.Any())
{
var modelIndexTemplate = new ModelIndexTemplate {
Model = codeModel
};
await Write(modelIndexTemplate, Path.Combine("models", "index.ts"));
var mapperIndexTemplate = new MapperIndexTemplate {
Model = codeModel
};
await Write(mapperIndexTemplate, Path.Combine("models", "mappers.ts"));
}
bool serviceHasMappableParameters = codeModel.Methods
.SelectMany(m => m.LogicalParameters)
.Any(p => p.Location != ParameterLocation.Body);
if (serviceHasMappableParameters)
{
await Write(new ParameterTemplate { Model = codeModel }, Path.Combine("models", "parameters.ts"));
}
//MethodGroups
if (codeModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupIndexTemplate {
Model = codeModel
};
await Write(methodGroupIndexTemplate, Path.Combine("operations", "index.ts"));
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var mappersTemplate = new MethodGroupMappersTemplate {
Model = methodGroupModel
};
await Write(mappersTemplate, Path.Combine("models", methodGroupModel.MappersModuleName + ".ts"));
var methodGroupTemplate = new MethodGroupTemplate {
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine("operations", methodGroupModel.TypeName.ToCamelCase() + ".ts"));
}
}
if (codeModel.GenerateMetadata)
{
// package.json
var packageJson = new PackageJson {
Model = codeModel
};
await Write(packageJson, Path.Combine("../", "package.json"));
//tsconfig.json
var nodeTsConfig = new TsConfig {
Model = new TsConfigModel(false)
};
await Write(nodeTsConfig, Path.Combine("../", "tsconfig.json"));
// webpack.config.js
var webpackConfig = new WebpackConfig {
Model = codeModel
};
await Write(webpackConfig, Path.Combine("../", "webpack.config.js"));
// .npmignore
var npmIgnore = new NpmIgnore {
Model = codeModel
};
await Write(npmIgnore, Path.Combine("../", ".npmignore"));
//README.md
var readme = new ReadmeTemplate {
Model = codeModel
};
await Write(readme, Path.Combine("../", "README.md"));
}
}
/// <summary>
/// Generate Python client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelPy;
if (codeModel == null)
{
throw new Exception("Code model is not a Python Code Model");
}
writeNamespaceFolders(codeModel);
if (codeModel.BasicSetupPy)
{
var setupTemplate = new SetupTemplate {
Model = codeModel
};
await Write(setupTemplate, "setup.py");
}
var noAsync = await Settings.Instance.Host.GetValue <bool?>("no-async");
var folderName = codeModel.NoNamespaceFolders?"":Path.Combine(codeModel.Namespace.Split('.'));
var serviceClientInitTemplate = new ServiceClientInitTemplate {
Model = codeModel
};
await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py"));
var configurationTemplate = new ConfigurationTemplate {
Model = codeModel
};
await Write(configurationTemplate, Path.Combine(folderName, "_configuration.py"));
// Writing service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, Path.Combine(folderName, "_" + codeModel.Name.ToPythonCase() + ".py"));
if (codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup))
{
var serviceClientOpTemplate = new ServiceClientOperationsTemplate {
Model = codeModel
};
await Write(serviceClientOpTemplate, Path.Combine(folderName, "operations", "_" + codeModel.Name.ToPythonCase() + "_operations.py"));
}
// do we need to write out the version template file?
var versionPath = Path.Combine(folderName, "version.py");
// protect the version file
await Settings.Instance.Host.ProtectFiles(versionPath);
if (true != await Settings.Instance.Host.GetValue <bool?>("keep-version-file") || string.IsNullOrEmpty(await Settings.Instance.Host.ReadFile(versionPath)))
{
var versionTemplate = new VersionTemplate {
Model = codeModel
};
// if they didn't say to keep the old file (or it was not there/empty), write it out.
await Write(versionTemplate, versionPath);
}
//Models
if (codeModel.ModelTypes.Any())
{
var modelInitTemplate = new ModelInitTemplate {
Model = codeModel
};
await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py"));
var modelTemplate = new ModelTemplate {
Model = codeModel.getSortedModels()
};
await Write(modelTemplate, Path.Combine(folderName, "models", "_models.py"));
modelTemplate.Python3Mode = true;
await Write(modelTemplate, Path.Combine(folderName, "models", "_models_py3.py"));
}
//MethodGroups
if (codeModel.MethodGroupModels.Any() || codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup))
{
var methodGroupIndexTemplate = new MethodGroupInitTemplate
{
Model = codeModel
};
await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py"));
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine(folderName, "operations", "_" + ((string)methodGroupModel.TypeName).ToPythonCase() + ".py"));
}
}
// Enums
if (codeModel.EnumTypes.Any())
{
var enumTemplate = new EnumTemplate {
Model = codeModel.EnumTypes
};
await Write(enumTemplate, Path.Combine(folderName, "models", "_" + codeModel.Name.ToPythonCase() + "_enums.py"));
}
// Async
if (noAsync != true)
{
var serviceClientInitTemplateAsync = new ServiceClientInitTemplateAsync {
Model = codeModel
};
await Write(serviceClientInitTemplateAsync, Path.Combine(folderName, "aio", "__init__.py"));
// Writing AIO service client
var serviceClientAsyncTemplate = new ServiceClientTemplateAsync {
Model = codeModel
};
await Write(serviceClientAsyncTemplate, Path.Combine(folderName, "aio", "_" + codeModel.Name.ToPythonCase() + "_async.py"));
if (codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup))
{
var serviceClientOpTemplateAsync = new ServiceClientOperationsTemplateAsync {
Model = codeModel
};
await Write(serviceClientOpTemplateAsync, Path.Combine(folderName, "aio", "operations_async", "_" + codeModel.Name.ToPythonCase() + "_operations_async.py"));
}
//MethodGroups
if (codeModel.MethodGroupModels.Any() || codeModel.MethodTemplateModels.Any(each => each.MethodGroup.IsCodeModelMethodGroup))
{
var methodGroupIndexTemplateAsync = new MethodGroupInitTemplate
{
Model = codeModel,
AsyncMode = true
};
await Write(methodGroupIndexTemplateAsync, Path.Combine(folderName, "aio", "operations_async", "__init__.py"));
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
// Build a Py3 version that import the Py2 one
var methodGroupTemplatePy3 = new MethodGroupTemplateAsync
{
Model = methodGroupModel
};
await Write(methodGroupTemplatePy3, Path.Combine(folderName, "aio", "operations_async", "_" + ((string)methodGroupModel.TypeName).ToPythonCase() + "_async.py"));
}
}
}
}
/// <summary>
/// Generates Go code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
// if preview-chk:true is specified verify that preview swagger is output under a preview subdirectory.
// this is a bit of a hack until we have proper support for this in the swagger->sdk bot so it's opt-in.
if (Settings.Instance.Host.GetValue <bool>("preview-chk").Result)
{
const string previewSubdir = "/preview/";
var files = await Settings.Instance.Host.GetValue <string[]>("input-file");
// only evaluate composite builds if all swaggers are preview as we don't have a well-defined model for mixed preview/stable swaggers
if (files.All(file => file.IndexOf(previewSubdir) > -1) &&
Settings.Instance.Host.GetValue <string>("output-folder").Result.IndexOf(previewSubdir) == -1)
{
throw new InvalidOperationException($"codegen for preview swagger {files[0]} must be under a preview subdirectory");
}
}
var codeModel = cm as CodeModelGo;
if (codeModel == null)
{
throw new Exception("Code model is not a Go Code Model");
}
// unfortunately there is an ordering issue here. during model generation we might
// flatten some types (but not all depending on type). then during client generation
// the validation codegen needs to know if a type was flattened so it can generate
// the correct code, so we need to generate models before clients.
// Models
var modelsTemplate = new ModelsTemplate
{
Model = codeModel
};
await Write(modelsTemplate, FormatFileName("models"));
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = codeModel
};
await Write(serviceClientTemplate, FormatFileName("client"));
// by convention the methods in the method group with an empty
// name go into the client template so skip them here.
HashSet <string> ReservedFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase)
{
"models",
"client",
"version",
"interfaces",
};
foreach (var methodGroup in codeModel.MethodGroups.Where(mg => !string.IsNullOrEmpty(mg.Name)))
{
if (ReservedFiles.Contains(methodGroup.Name.Value))
{
methodGroup.Name += "group";
}
ReservedFiles.Add(methodGroup.Name);
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroup
};
await Write(methodGroupTemplate, FormatFileName(methodGroup.Name).ToLowerInvariant());
}
// interfaces
var interfacesTemplate = new InterfacesTemplate {
Model = codeModel
};
await Write(interfacesTemplate, FormatFileName($"{CodeNamerGo.InterfacePackageName(codeModel.Namespace)}/interfaces"));
// Version
var versionTemplate = new VersionTemplate {
Model = codeModel
};
await Write(versionTemplate, FormatFileName("version"));
// go.mod file, opt-in by specifying the gomod-root arg
var modRoot = Settings.Instance.Host.GetValue <string>("gomod-root").Result;
if (!string.IsNullOrWhiteSpace(modRoot))
{
var normalized = Settings.Instance.Host.GetValue <string>("output-folder").Result.Replace('\\', '/');
var i = normalized.IndexOf(modRoot);
if (i == -1)
{
throw new Exception($"didn't find module root '{modRoot}' in output path '{normalized}'");
}
// module name is everything to the right of the start of the module root
var gomodTemplate = new GoModTemplate {
Model = new GoMod(normalized.Substring(i))
};
await Write(gomodTemplate, $"{StagingDir()}go.mod");
}
}
/// <summary>
/// Generate Python client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelPy;
if (codeModel == null)
{
throw new Exception("Code model is not a Python Code Model");
}
// Service client
string[] namespaceParts = codeModel.Namespace.Split('.');
for (int i = 1; i < namespaceParts.Length; ++i)
{
string initFolderName = Path.Combine(namespaceParts.Take(i).ToArray());
await Write("__import__('pkg_resources').declare_namespace(__name__)",
Path.Combine(initFolderName, "__init__.py"), true);
}
var folderName = codeModel.Name.ToPythonCase().ToLower();
var setupTemplate = new SetupTemplate {
Model = codeModel
};
await Write(setupTemplate, "setup.py");
var serviceClientInitTemplate = new ServiceClientInitTemplate {
Model = codeModel
};
await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py"));
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, Path.Combine(folderName, codeModel.Name.ToPythonCase() + ".py"));
var versionTemplate = new VersionTemplate {
Model = codeModel
};
await Write(versionTemplate, Path.Combine(folderName, "version.py"));
var exceptionTemplate = new ExceptionTemplate {
Model = codeModel
};
await Write(exceptionTemplate, Path.Combine(folderName, "exceptions.py"));
var credentialTemplate = new CredentialTemplate {
Model = codeModel
};
await Write(credentialTemplate, Path.Combine(folderName, "credentials.py"));
//Models
if (codeModel.ModelTypes.Any())
{
var modelInitTemplate = new ModelInitTemplate {
Model = codeModel
};
await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py"));
foreach (var modelType in codeModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine(folderName, "models", ((string)modelType.Name).ToPythonCase() + ".py"));
}
}
//MethodGroups
if (codeModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupInitTemplate
{
Model = codeModel
};
await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py"));
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine(folderName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py"));
}
}
// Enums
if (codeModel.EnumTypes.Any())
{
var enumTemplate = new EnumTemplate {
Model = codeModel.EnumTypes
};
await Write(enumTemplate, Path.Combine(folderName, "models", codeModel.Name.ToPythonCase() + "_enums.py"));
}
}
/// <summary>
/// Generate NodeJS client code
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var disableTypeScriptGeneration = Singleton<GeneratorSettingsJs>.Instance.DisableTypeScriptGeneration;
var codeModel = cm as CodeModelJs;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a NodeJS code model.");
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate {Model = codeModel};
await Write(serviceClientTemplate, codeModel.Name.ToCamelCase() + ".js");
if (!disableTypeScriptGeneration)
{
var serviceClientTemplateTS = new ServiceClientTemplateTS {Model = codeModel};
await Write(serviceClientTemplateTS, codeModel.Name.ToCamelCase() + ".d.ts");
}
//Models
if (codeModel.ModelTypes.Any())
{
var modelIndexTemplate = new ModelIndexTemplate {Model = codeModel};
await Write(modelIndexTemplate, Path.Combine("models", "index.js"));
if (!disableTypeScriptGeneration)
{
var modelIndexTemplateTS = new ModelIndexTemplateTS {Model = codeModel};
await Write(modelIndexTemplateTS, Path.Combine("models", "index.d.ts"));
}
foreach (var modelType in codeModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate {Model = modelType};
await Write(modelTemplate, Path.Combine("models", modelType.NameAsFileName.ToCamelCase() + ".js"));
}
}
//MethodGroups
if (codeModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupIndexTemplate {Model = codeModel};
await Write(methodGroupIndexTemplate, Path.Combine("operations", "index.js"));
if (!disableTypeScriptGeneration)
{
var methodGroupIndexTemplateTS = new MethodGroupIndexTemplateTS {Model = codeModel};
await Write(methodGroupIndexTemplateTS, Path.Combine("operations", "index.d.ts"));
}
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate {Model = methodGroupModel};
await
Write(methodGroupTemplate,
Path.Combine("operations", methodGroupModel.TypeName.ToCamelCase() + ".js"));
}
}
}
/// <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"));
}
}
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="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"));
}
}
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);
}
}
/// <summary>
/// Generates Ruby code for service client.
/// </summary>
/// <param name="serviceClient">The service client.</param>
/// <returns>Async task for generating SDK files.</returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate,
Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension));
// Method groups
foreach (var group in serviceClient.MethodGroups)
{
var groupTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(groupTemplate,
Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(group) + ImplementationFileExtension));
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(model, serviceClient.ModelTypes)
};
await Write(modelTemplate,
Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate,
Path.Combine(modelsPath, RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension));
}
// Requirements
var requirementsTemplate = new RequirementsTemplate
{
Model = new RequirementsTemplateModel(serviceClient, this.packageName ?? this.sdkName, this.ImplementationFileExtension, this.Settings.Namespace, this.packageVersion),
};
await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(this.packageName ?? this.sdkName) + ImplementationFileExtension);
// Version File
if (!string.IsNullOrEmpty(this.packageVersion))
{
var versionTemplate = new VersionTemplate
{
Model = new VersionTemplateModel(packageVersion),
};
await Write(versionTemplate, Path.Combine(sdkPath, "version" + ImplementationFileExtension));
}
// Module Definition File
if (!string.IsNullOrEmpty(Settings.Namespace))
{
var modTemplate = new ModuleDefinitionTemplate
{
Model = new ModuleDefinitionTemplateModel(Settings.Namespace),
};
await Write(modTemplate, Path.Combine(sdkPath, "module_definition" + ImplementationFileExtension));
}
}
/// <summary>
/// Generates Go code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelSwift;
if (codeModel == null)
{
throw new Exception("Code model is not a Swift Code Model");
}
// unfortunately there is an ordering issue here. during model generation we might
// flatten some types (but not all depending on type). then during client generation
// the validation codegen needs to know if a type was flattened so it can generate
// the correct code, so we need to generate models before clients.
//Protocols
foreach (CompositeTypeSwift modelType in cm.ModelTypes.Union(codeModel.HeaderTypes))
{
var modelProtocolTemplate = new ModelProtocolTemplate {
Model = modelType
};
await Write(modelProtocolTemplate, Path.Combine("protocols", $"{modelType.Name}Protocol{ImplementationFileExtension}"));
}
//Models
foreach (CompositeTypeSwift modelType in cm.ModelTypes.Union(codeModel.HeaderTypes))
{
var modelTemplate = new DataModelTemplate {
Model = modelType
};
await Write(modelTemplate, Path.Combine("data", $"{modelType.TypeName}{ImplementationFileExtension}"));
}
//Model Tests
foreach (CompositeTypeSwift modelType in cm.ModelTypes.Union(codeModel.HeaderTypes))
{
var modelTemplate = new DataModelTestTemplate {
Model = modelType
};
//await Write(modelTemplate, Path.Combine("tests", $"{modelType.Name}Test{ImplementationFileExtension}"));
}
// Enums
foreach (EnumTypeSwift enumType in cm.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
await Write(enumTemplate, Path.Combine("data", $"{enumTemplate.Model.Name}Enum{ImplementationFileExtension}"));
}
// Command
foreach (var methodGroup in codeModel.MethodGroups)
{
if (string.IsNullOrWhiteSpace(methodGroup.Name))
{
methodGroup.Name = "Service";
}
foreach (var method in methodGroup.Methods)
{
var methodContextTemplate = new MethodCommandTemplate
{
Model = (MethodSwift)method
};
await Write(methodContextTemplate, Path.Combine("commands", $"{methodGroup.Name + method.Name}{ImplementationFileExtension}"));
}
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = codeModel
};
await Write(serviceClientTemplate, Path.Combine("commands", FormatFileName("DataFactory")));
// Package.swift
if (!string.IsNullOrWhiteSpace(CodeModelSwift.FrameworkName))
{
var packageTemplate = new PackageTemplate
{
Model = codeModel
};
await Write(packageTemplate, "Package.swift");
}
foreach (var methodGroup in codeModel.MethodGroups)
{
if (string.IsNullOrWhiteSpace(methodGroup.Name))
{
methodGroup.Name = "Service";
}
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroup
};
await Write(methodGroupTemplate, Path.Combine("commands", FormatFileName(methodGroup.Name)));
}
}
/// <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,
RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension);
// Method groups
foreach (var group in serviceClient.MethodGroups)
{
var groupTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(groupTemplate,
RubyCodeNamer.UnderscoreCase(group) + ImplementationFileExtension);
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(model, serviceClient),
};
await Write(modelTemplate, Path.Combine("models",
RubyCodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine("models", RubyCodeNamer.UnderscoreCase(enumTemplate.Model.TypeDefinitionName) + ImplementationFileExtension));
}
// Requirements
var requirementsTemplate = new RequirementsTemplate
{
Model = new RequirementsTemplateModel(serviceClient),
};
await Write(requirementsTemplate,
RubyCodeNamer.UnderscoreCase("sdk_requirements") + ImplementationFileExtension);
}
/// <summary>
/// Generates Go code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var folder = Path.GetFullPath(Settings.Instance.Host.GetValue <string>("output-folder").Result).Replace('\\', '/');
// check if the namespace contains illegal characters
var ns = Settings.Instance.Host.GetValue <string>("namespace").Result;
if (Settings.Instance.Host.GetValue <bool>("namespace-chk").Result)
{
NamespaceCheck(ns);
}
// if preview-chk:true is specified verify that preview swagger is output under a preview subdirectory.
// this is a bit of a hack until we have proper support for this in the swagger->sdk bot so it's opt-in.
if (Settings.Instance.Host.GetValue <bool>("preview-chk").Result)
{
PreviewCheck(folder);
}
var codeModel = cm as CodeModelGo;
if (codeModel == null)
{
throw new Exception("Code model is not a Go Code Model");
}
// unfortunately there is an ordering issue here. during model generation we might
// flatten some types (but not all depending on type). then during client generation
// the validation codegen needs to know if a type was flattened so it can generate
// the correct code, so we need to generate models before clients.
// Models
var modelsTemplate = new ModelsTemplate
{
Model = codeModel
};
await Write(modelsTemplate, FormatFileName("models"));
// Enums - while initially enums should be part of the models, to decrease the size of the models.go file,
// we separate the enums definitions out of the models.go file
var enums = codeModel.EnumTypes.Cast <EnumTypeGo>().ToList();
if (enums.Any())
{
var enumsTemplate = new EnumsTemplate
{
Model = codeModel
};
await Write(enumsTemplate, FormatFileName("enums"));
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = codeModel
};
await Write(serviceClientTemplate, FormatFileName("client"));
// by convention the methods in the method group with an empty
// name go into the client template so skip them here.
HashSet <string> ReservedFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase)
{
"models",
"client",
"version",
"interfaces",
"enums",
};
foreach (var methodGroup in codeModel.MethodGroups.Where(mg => !string.IsNullOrEmpty(mg.Name)))
{
if (ReservedFiles.Contains(methodGroup.Name.Value))
{
methodGroup.Name += "group";
}
ReservedFiles.Add(methodGroup.Name);
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroup
};
await Write(methodGroupTemplate, FormatFileName(methodGroup.Name).ToLowerInvariant());
}
// interfaces
var interfacesTemplate = new InterfacesTemplate {
Model = codeModel
};
await Write(interfacesTemplate, FormatFileName($"{CodeNamerGo.InterfacePackageName(codeModel.Namespace)}/interfaces"));
// Version
var versionTemplate = new VersionTemplate {
Model = codeModel
};
await Write(versionTemplate, FormatFileName("version"));
// go.mod file, opt-in by specifying the gomod-root arg
var modRoot = Settings.Instance.Host.GetValue <string>("gomod-root").Result;
if (!string.IsNullOrWhiteSpace(modRoot))
{
var i = folder.IndexOf(modRoot);
if (i == -1)
{
throw new Exception($"didn't find module root '{modRoot}' in output path '{folder}'");
}
var goVersion = Settings.Instance.Host.GetValue <string>("go-version").Result;
if (string.IsNullOrWhiteSpace(goVersion))
{
goVersion = defaultGoVersion;
}
// module name is everything to the right of the start of the module root
var gomodTemplate = new GoModTemplate {
Model = new GoMod(folder.Substring(i), goVersion)
};
await Write(gomodTemplate, $"{StagingDir()}go.mod");
}
// metadata
var metadataOutputFolder = Settings.Instance.Host.GetValue <string>("metadata-output-folder").Result;
if (!string.IsNullOrWhiteSpace(metadataOutputFolder))
{
var metadataTemplate = new MetadataTemplate
{
Model = new MetadataGo(Settings.Instance.Host.GetValue <string[]>("input-file").Result, folder, ns)
};
var tag = Settings.Instance.Host.GetValue <string>("tag").Result;
await Write(metadataTemplate, $"{metadataOutputFolder}/{tag}.json");
}
}
/// <summary>
/// Generate Python client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
var serviceClientTemplateModel = new ServiceClientTemplateModel(serviceClient);
if (!string.IsNullOrWhiteSpace(Version))
{
serviceClientTemplateModel.Version = Version;
}
// Service client
var setupTemplate = new SetupTemplate
{
Model = serviceClientTemplateModel
};
await Write(setupTemplate, "setup.py");
var serviceClientInitTemplate = new ServiceClientInitTemplate
{
Model = serviceClientTemplateModel
};
await Write(serviceClientInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "__init__.py"));
var serviceClientTemplate = new ServiceClientTemplate
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientTemplate, Path.Combine(serviceClientTemplateModel.PackageName, serviceClientTemplateModel.Name.ToPythonCase() + ".py"));
var versionTemplate = new VersionTemplate
{
Model = serviceClientTemplateModel,
};
await Write(versionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "version.py"));
var exceptionTemplate = new ExceptionTemplate
{
Model = serviceClientTemplateModel,
};
await Write(exceptionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "exceptions.py"));
var credentialTemplate = new CredentialTemplate
{
Model = serviceClientTemplateModel,
};
await Write(credentialTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "credentials.py"));
//Models
if (serviceClient.ModelTypes.Any())
{
var modelInitTemplate = new ModelInitTemplate
{
Model = new ModelInitTemplateModel(serviceClient)
};
await Write(modelInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", "__init__.py"));
foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", modelType.Name.ToPythonCase() + ".py"));
}
}
//MethodGroups
if (serviceClientTemplateModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupInitTemplate
{
Model = serviceClientTemplateModel
};
await Write(methodGroupIndexTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", "__init__.py"));
foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", methodGroupModel.MethodGroupType.ToPythonCase() + ".py"));
}
}
// Enums
if (serviceClient.EnumTypes.Any())
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(serviceClient.EnumTypes),
};
await Write(enumTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", serviceClientTemplateModel.Name.ToPythonCase() + "_enums.py"));
}
}
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>
/// Generates Ruby code for service client.
/// </summary>
/// <param name="cm">The code model.</param>
/// <returns>Async task for generating SDK files.</returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelRb;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a Ruby code model.");
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate,
Path.Combine(GeneratorSettingsRb.Instance.sdkPath, CodeNamer.UnderscoreCase(codeModel.Name) + ImplementationFileExtension));
// Method groups
foreach (MethodGroupRb group in codeModel.Operations.Where(each => !each.IsCodeModelMethodGroup))
{
var groupTemplate = new MethodGroupTemplate {
Model = group
};
await Write(groupTemplate,
Path.Combine(GeneratorSettingsRb.Instance.sdkPath, CodeNamer.UnderscoreCase(@group.TypeName) + ImplementationFileExtension));
}
// Models
foreach (CompositeTypeRb model in codeModel.ModelTypes)
{
var modelTemplate = new ModelTemplate {
Model = model
};
await Write(modelTemplate,
Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension));
}
// Enums
foreach (EnumTypeRb enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
await Write(enumTemplate,
Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(enumTemplate.Model.Name) + ImplementationFileExtension));
}
// Requirements
var requirementsTemplate = new RequirementsTemplate
{
Model = new RequirementsRb(codeModel, this)
};
await Write(requirementsTemplate,
CodeNamer.UnderscoreCase(GeneratorSettingsRb.Instance.packageName ?? GeneratorSettingsRb.Instance.sdkName) + ImplementationFileExtension);
// Version File
if (!string.IsNullOrEmpty(GeneratorSettingsRb.Instance.packageVersion))
{
var versionTemplate = new VersionTemplate {
Model = GeneratorSettingsRb.Instance.packageVersion
};
await Write(versionTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "version" + ImplementationFileExtension));
}
// Module Definition File
if (!string.IsNullOrEmpty(Settings.Instance.Namespace))
{
var modTemplate = new ModuleDefinitionTemplate {
Model = GeneratorSettingsRb.Instance.ModuleDeclarations
};
await Write(modTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "module_definition" + ImplementationFileExtension));
}
}
/// <summary>
/// Generate Python client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelPy;
if (codeModel == null)
{
throw new Exception("Code model is not a Python Code Model");
}
writeNamespaceFolders(codeModel);
if (codeModel.BasicSetupPy)
{
var setupTemplate = new SetupTemplate {
Model = codeModel
};
await Write(setupTemplate, "setup.py");
}
var folderName = codeModel.NoNamespaceFolders?"":Path.Combine(codeModel.Namespace.Split('.'));
var serviceClientInitTemplate = new ServiceClientInitTemplate {
Model = codeModel
};
await Write(serviceClientInitTemplate, Path.Combine(folderName, "__init__.py"));
var serviceClientTemplate = new ServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, Path.Combine(folderName, codeModel.Name.ToPythonCase() + ".py"));
var versionTemplate = new VersionTemplate {
Model = codeModel
};
await Write(versionTemplate, Path.Combine(folderName, "version.py"));
//Models
if (codeModel.ModelTypes.Any())
{
var modelInitTemplate = new ModelInitTemplate {
Model = codeModel
};
await Write(modelInitTemplate, Path.Combine(folderName, "models", "__init__.py"));
foreach (var modelType in codeModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine(folderName, "models", ((string)modelType.Name).ToPythonCase() + ".py"));
// Rebuild the same in Python 3 mode
modelTemplate.Python3Mode = true;
await Write(modelTemplate, Path.Combine(folderName, "models", ((string)modelType.Name).ToPythonCase() + "_py3.py"));
}
}
//MethodGroups
if (codeModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupInitTemplate
{
Model = codeModel
};
await Write(methodGroupIndexTemplate, Path.Combine(folderName, "operations", "__init__.py"));
foreach (var methodGroupModel in codeModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine(folderName, "operations", ((string)methodGroupModel.TypeName).ToPythonCase() + ".py"));
}
}
// Enums
if (codeModel.EnumTypes.Any())
{
var enumTemplate = new EnumTemplate {
Model = codeModel.EnumTypes
};
await Write(enumTemplate, Path.Combine(folderName, "models", codeModel.Name.ToPythonCase() + "_enums.py"));
}
}
/// <summary>
/// Generate Python client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
var serviceClientTemplateModel = new ServiceClientTemplateModel(serviceClient);
if (!string.IsNullOrWhiteSpace(Version))
{
serviceClientTemplateModel.Version = Version;
}
// Service client
var setupTemplate = new SetupTemplate
{
Model = serviceClientTemplateModel
};
await Write(setupTemplate, "setup.py");
var serviceClientInitTemplate = new ServiceClientInitTemplate
{
Model = serviceClientTemplateModel
};
await Write(serviceClientInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "__init__.py"));
var serviceClientTemplate = new ServiceClientTemplate
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientTemplate, Path.Combine(serviceClientTemplateModel.PackageName, serviceClientTemplateModel.Name.ToPythonCase() + ".py"));
var versionTemplate = new VersionTemplate
{
Model = serviceClientTemplateModel,
};
await Write(versionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "version.py"));
var exceptionTemplate = new ExceptionTemplate
{
Model = serviceClientTemplateModel,
};
await Write(exceptionTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "exceptions.py"));
var credentialTemplate = new CredentialTemplate
{
Model = serviceClientTemplateModel,
};
await Write(credentialTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "credentials.py"));
//Models
if (serviceClient.ModelTypes.Any())
{
var modelInitTemplate = new ModelInitTemplate
{
Model = new ModelInitTemplateModel(serviceClient)
};
await Write(modelInitTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", "__init__.py"));
foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", modelType.Name.ToPythonCase() + ".py"));
}
}
//MethodGroups
if (serviceClientTemplateModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupInitTemplate
{
Model = serviceClientTemplateModel
};
await Write(methodGroupIndexTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", "__init__.py"));
foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels)
{
var methodGroupTemplate = new MethodGroupTemplate
{
Model = methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "operations", methodGroupModel.MethodGroupType.ToPythonCase() + ".py"));
}
}
// Enums
if (serviceClient.EnumTypes.Any())
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(serviceClient.EnumTypes),
};
await Write(enumTemplate, Path.Combine(serviceClientTemplateModel.PackageName, "models", serviceClientTemplateModel.Name.ToPythonCase() + "_enums.py"));
}
}
/// <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));
}