public static EnumTemplate AddEnum(this NamespaceTemplate namespaceTemplate, string name, TypeTemplate basedOn = null)
{
EnumTemplate enumTemplate = new EnumTemplate(namespaceTemplate, name, basedOn);
namespaceTemplate.Children.Add(enumTemplate);
return(enumTemplate);
}
public virtual void Write(ICodeFragment fragment, IOutputCache output)
{
BaseLanguage language = this.options.Language.CastTo <BaseLanguage>();
EnumTemplate template = (EnumTemplate)fragment;
output.Add(template.Attributes)
.Add(language.ClassScope)
.Add(" enum ")
.Add(template.Name);
if (template.BasedOn != null)
{
output.Add(" : ").Add(template.BasedOn);
}
output.StartBlock();
EnumValueTemplate last = template.Values.LastOrDefault();
foreach (EnumValueTemplate enumTemplateValue in template.Values)
{
output.Add($"{enumTemplateValue.FormattedName} = ")
.Add(enumTemplateValue.Value)
.Add(last == enumTemplateValue ? string.Empty : ",")
.BreakLine();
}
output.EndBlock();
}
/// <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"));
}
}
private void GenerateEnum(XmlEnumItem item)
{
var template = new EnumTemplate(item);
var data = template.TransformText();
_codeWriter.Write(Utils.EnumsNamespace, item.name, data);
}
public void Run(Options options)
{
_grammar = Utils.LoadGrammar(options.Grammar);
Directory.CreateDirectory(options.Output);
foreach (var instruction in _grammar.OperandKinds)
{
switch (instruction.Value.Category)
{
case SpirvOperandCategory.BitEnum:
{
var text = new FlagTemplate(instruction.Value).TransformText();
Utils.SaveText(Path.Combine(options.Output, instruction.Value.Name + ".cs"), text);
break;
}
case SpirvOperandCategory.ValueEnum:
{
var text = new EnumTemplate(instruction.Value).TransformText();
Utils.SaveText(Path.Combine(options.Output, instruction.Value.Name + ".cs"), text);
break;
}
}
}
{
var text = new NestedInstruction(_grammar.Instructions.Select(_ => _.Value).Where(_ => _nestedInstructions.Contains(_.Name))).TransformText();
Utils.SaveText(Path.Combine(options.Output, "NestedInstruction.cs"), text);
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient">The service client.</param>
/// <returns>Async tasks which generates SDK files.</returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension));
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(operationsTemplate.Model.MethodGroupName) + ImplementationFileExtension));
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) || model.Extensions.ContainsKey(AzureExtensions.AzureResourceExtension))
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(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 AzureRequirementsTemplateModel(serviceClient, sdkName, this.ImplementationFileExtension),
};
await Write(requirementsTemplate,
RubyCodeNamer.UnderscoreCase(sdkName) + ImplementationFileExtension);
}
public void EnumWriter()
{
EnumTemplate template = new EnumTemplate((NamespaceTemplate)null, "test");
template.Values.Add(new EnumValueTemplate("value", Code.Number(0)));
EnumWriter writer = new EnumWriter();
writer.Write(template, this.output);
Assert.AreEqual("public enum test\r\n{\r\n value = 0\r\n}", this.output.ToString());
}
private void TransformEnums(SmartAppInfo manifest)
{
var enums = manifest.DataModel.Entities.Where(e => e.IsEnum).AsEnumerable();
foreach (var model in enums)
{
var template = new EnumTemplate(model, manifest.Id, Constants.DataNamespace);
_writingService.WriteFile(Path.Combine(_context.BasePath, template.OutputPath, $"{model.Id}.g.cs"), template.TransformText());
}
}
private void GenerateEnum(CodeGenerateDto dto)
{
foreach (var enumModel in dto.Enums)
{
var enumTemplate = new EnumTemplate();
enumTemplate.Model = enumModel;
Directory.CreateDirectory($@"{dto.BasePath}\ApplicationCore\Enums");
System.IO.File.WriteAllText($@"{dto.BasePath}\ApplicationCore\Enums\{enumModel.Name}.cs", enumTemplate.TransformText());
}
}
/// <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}"));
}
}
private TypeGeneratorResult GenerateEnum(string typeName)
{
var template = new EnumTemplate() as ITemplate;
template.Initialize(new EnumTemplateModel(typeName, _schema));
return(new TypeGeneratorResult
{
TypeName = typeName,
Code = template.Render()
});
}
/// <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);
}
public void ProtocolTest()
{
var versions = MetaDb.Protocol.SelectToken("VersionDummy.Protocol").ToObject <Dictionary <string, object> >();
var tmpl = new EnumTemplate
{
EnumName = "Protocol",
Enums = versions
};
Console.WriteLine(tmpl.TransformText());
}
public void RenderEnumFile(List <EnumModel> models)
{
if (!Directory.Exists(_outputPath + "Entity\\" + NormalizeTableName + "\\"))
{
Directory.CreateDirectory(_outputPath + "Entity\\" + NormalizeTableName + "\\");
}
var enumTemplate = new EnumTemplate(models, _projectName);
var output = enumTemplate.TransformText();
var outputPath = _outputPath + "Entity\\" + NormalizeTableName + "\\" + "Enum" + NormalizeTableName + ".cs";
File.WriteAllText(outputPath, output);
}
/// <summary>Generates the type.</summary>
/// <param name="fallbackTypeName">The fallback type name.</param>
/// <returns>The code.</returns>
public override TypeGeneratorResult GenerateType(string fallbackTypeName)
{
var typeName = _schema.GetTypeName(Settings.TypeNameGenerator);
if (string.IsNullOrEmpty(typeName))
{
typeName = fallbackTypeName;
}
if (_schema.IsEnumeration)
{
if (_schema.Type == JsonObjectType.Integer)
{
typeName = typeName + "AsInteger";
}
var template = new EnumTemplate() as ITemplate;
template.Initialize(new EnumTemplateModel(typeName, _schema));
return(new TypeGeneratorResult
{
TypeName = typeName,
Code = template.Render()
});
}
else
{
var properties = _schema.Properties.Values.Select(property => new PropertyModel(property, typeName, _resolver, Settings)).ToList();
var hasInheritance = _schema.AllOf.Count == 1;
var baseClass = hasInheritance ? _resolver.Resolve(_schema.AllOf.First(), true, string.Empty) : null;
var template = Settings.CreateTemplate(typeName);
template.Initialize(new // TODO: Create model class
{
Class = Settings.ExtendedClasses?.Contains(typeName) == true ? typeName + "Base" : typeName,
RealClass = typeName,
HasDescription = !(_schema is JsonProperty) && !string.IsNullOrEmpty(_schema.Description),
Description = ConversionUtilities.RemoveLineBreaks(_schema.Description),
HasInheritance = hasInheritance,
Inheritance = hasInheritance ? " extends " + baseClass : string.Empty,
Properties = properties
});
return(new TypeGeneratorResult
{
TypeName = typeName,
BaseTypeName = baseClass,
Code = template.Render()
});
}
}
private static void GenerateEnumsInScope(string outputDir, EngineApi engineApi, List <EngineEnum> enums, string scope)
{
scope = string.IsNullOrEmpty(scope) ? "Global" : scope;
string output = EnumTemplate.Render(enums, scope);
Console.WriteLine(scope + "_enums.cs");
Directory.CreateDirectory($"{outputDir}/Enums");
using (StreamWriter SW =
new StreamWriter($"{outputDir}/Enums/{scope}.cs")) {
SW.Write(output);
}
}
protected virtual EnumTemplate WriteEnum(IModelConfiguration configuration, ModelTransferObject model, string nameSpace, List <FileTemplate> files)
{
if (model.EnumValues == null)
{
throw new InvalidOperationException("Can not write enum without values");
}
EnumTemplate enumTemplate = files.AddFile(configuration.RelativePath, configuration.AddHeader)
.AddNamespace(nameSpace)
.AddEnum(model.Name);
foreach (KeyValuePair <string, int> pair in model.EnumValues)
{
string formattedName = Formatter.FormatProperty(pair.Key, configuration);
enumTemplate.Values.Add(new EnumValueTemplate(pair.Key, Code.Number(pair.Value), formattedName));
}
return(enumTemplate);
}
protected virtual EnumTemplate WriteEnum(ModelTransferObject model, string relativePath)
{
if (model.EnumValues == null)
{
throw new InvalidOperationException("Can not write enum without values");
}
IOptions modelOptions = this.Options.Get(model);
EnumTemplate enumTemplate = this.files.AddFile(relativePath, modelOptions)
.WithName(model.FileName)
.AddNamespace(modelOptions.SkipNamespace ? string.Empty : model.Namespace)
.AddEnum(model.Name);
foreach (KeyValuePair <string, int> pair in model.EnumValues)
{
string formattedName = Formatter.FormatProperty(pair.Key, modelOptions);
enumTemplate.Values.Add(new EnumValueTemplate(pair.Key, Code.Number(pair.Value), formattedName));
}
return(enumTemplate);
}
private Task GenerateMultipleFileAsync(string output, string resolverName, ObjectSerializationInfo[] objectInfo, EnumSerializationInfo[] enumInfo, UnionSerializationInfo[] unionInfo, string namespaceDot, string multioutSymbol, GenericSerializationInfo[] genericInfo)
{
string GetNamespace(INamespaceInfo x)
{
if (x.Namespace == null)
{
return(namespaceDot + "Formatters");
}
return(namespaceDot + "Formatters." + x.Namespace);
}
var waitingTasks = new Task[objectInfo.Length + enumInfo.Length + unionInfo.Length + 1];
var waitingIndex = 0;
foreach (var x in objectInfo)
{
var ns = namespaceDot + "Formatters" + (x.Namespace is null ? string.Empty : "." + x.Namespace);
var template = x.IsStringKey ? new StringKeyFormatterTemplate(ns, new[] { x }) : (IFormatterTemplate) new FormatterTemplate(ns, new[] { x });
var text = template.TransformText();
waitingTasks[waitingIndex++] = OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text);
}
foreach (var x in enumInfo)
{
var template = new EnumTemplate(GetNamespace(x), new[] { x });
var text = template.TransformText();
waitingTasks[waitingIndex++] = OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text);
}
foreach (var x in unionInfo)
{
var template = new UnionTemplate(GetNamespace(x), new[] { x });
var text = template.TransformText();
waitingTasks[waitingIndex++] = OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text);
}
var resolverTemplate = new ResolverTemplate(namespaceDot + "Resolvers", namespaceDot + "Formatters", resolverName, genericInfo.Where(x => !x.IsOpenGenericType).Cast <IResolverRegisterInfo>().Concat(enumInfo).Concat(unionInfo).Concat(objectInfo.Where(x => !x.IsOpenGenericType)).ToArray());
waitingTasks[waitingIndex] = OutputToDirAsync(output, resolverTemplate.Namespace, resolverTemplate.ResolverName, multioutSymbol, resolverTemplate.TransformText());
return(Task.WhenAll(waitingTasks));
}
public override void Write(ICodeFragment fragment, IOutputCache output)
{
EnumTemplate template = (EnumTemplate)fragment;
template.BasedOn = null;
base.Write(fragment, output);
output.BreakLine()
.Add($"export const {template.Name}Values = [").Add(template.Values.Select(x => x.Value), ", ").Add("]").CloseLine()
.Add($"export const {template.Name}Names = [").Add(template.Values.Select(x => Code.String(x.Name)), ", ").Add("]").CloseLine()
.Add($"export const {template.Name}ValueMapping: {{ [key: number]: string }} = {{ ");
bool isFirst = true;
foreach (EnumValueTemplate value in template.Values)
{
if (isFirst)
{
isFirst = false;
}
else
{
output.Add(", ");
}
output.Add(value.Value).Add(": ").Add(Code.String(value.Name));
}
output.Add(" }").CloseLine()
.Add($"export const {template.Name}NameMapping: {{ [key: string]: number }} = {{ ");
isFirst = true;
foreach (EnumValueTemplate value in template.Values)
{
if (isFirst)
{
isFirst = false;
}
else
{
output.Add(", ");
}
output.Add(Code.String(value.Name)).Add(": ").Add(value.Value);
}
output.Add(" }").CloseLine();
}
/// <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 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 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>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
var serviceClientTemplateModel = new AzureServiceClientTemplateModel(serviceClient);
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientTemplate, Path.Combine("implementation", serviceClient.Name.ToPascalCase() + "Impl.java"));
var serviceClientInterfaceTemplate = new AzureServiceClientInterfaceTemplate
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientInterfaceTemplate, serviceClient.Name.ToPascalCase() + ".java");
//Models
foreach (var modelType in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
if (modelType.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)modelType.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
if (modelType.IsResource())
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(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 AzureMethodGroupTemplate
{
Model = (AzureMethodGroupTemplateModel)methodGroupModel
};
await Write(methodGroupTemplate, Path.Combine("implementation", methodGroupModel.MethodGroupType.ToPascalCase() + "Impl.java"));
var methodGroupInterfaceTemplate = new AzureMethodGroupInterfaceTemplate
{
Model = (AzureMethodGroupTemplateModel)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"));
}
// Page class
foreach (var pageClass in pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new PageTemplateModel(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value),
};
await Write(pageTemplate, Path.Combine("models", pageTemplate.Model.TypeDefinitionName + ".java"));
}
// Exceptions
foreach (var exceptionType in serviceClient.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType, serviceClient),
};
await Write(exceptionTemplate, Path.Combine("models", exceptionTemplate.Model.ExceptionTypeDefinitionName + ".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, "implementation")
}, Path.Combine("implementation", _packageInfoFileName));
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name, "models")
}, Path.Combine("models", _packageInfoFileName));
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
var extensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, null),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, group),
};
await Write(operationExtensionsTemplate, operationExtensionsTemplate.Model.ExtensionName + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
if (model.Extensions.ContainsKey(ExternalExtension) && (bool) model.Extensions[ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(model),
};
await Write(modelTemplate, Path.Combine("Models", model.Name + ".cs"));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine("Models", enumTemplate.Model.TypeDefinitionName + ".cs"));
}
}
public static TypeTemplate ToType(this EnumTemplate enumTemplate)
{
return(Code.Instance.Type(enumTemplate.Name));
}
public static EnumTemplate FormatName(this EnumTemplate enumTemplate, IOptions options, bool force = false)
{
enumTemplate.Name = Formatter.FormatClass(enumTemplate.Name, options, force);
return(enumTemplate);
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
var serviceClientTemplateModel = new AzureServiceClientTemplateModel(serviceClient);
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientTemplate, serviceClient.Name.ToPascalCase() + "Impl.java");
var serviceClientInterfaceTemplate = new AzureServiceClientInterfaceTemplate
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientInterfaceTemplate, serviceClient.Name.ToPascalCase() + ".java");
//Models
foreach (var modelType in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
if (modelType.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)modelType.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(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 AzureMethodGroupTemplate
{
Model = (AzureMethodGroupTemplateModel)methodGroupModel
};
await Write(methodGroupTemplate, methodGroupModel.MethodGroupType.ToPascalCase() + "Impl.java");
var methodGroupInterfaceTemplate = new AzureMethodGroupInterfaceTemplate
{
Model = (AzureMethodGroupTemplateModel)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"));
}
// Page class
foreach (var pageClass in pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new PageTemplateModel(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value),
};
await Write(pageTemplate, Path.Combine("models", pageTemplate.Model.TypeDefinitionName + ".java"));
}
// Exceptions
foreach (var exceptionType in serviceClient.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType, serviceClient),
};
await Write(exceptionTemplate, Path.Combine("models", exceptionTemplate.Model.ExceptionTypeDefinitionName + ".java"));
}
// package-info.java
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name)
}, _packageInfoFileName);
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(serviceClient, serviceClient.Name, true)
}, Path.Combine("models", _packageInfoFileName));
}
/// <summary>
/// Generates 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>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient">The service client.</param>
/// <returns>Async tasks which generates SDK files.</returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension));
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(operationsTemplate.Model.MethodGroupName) + ImplementationFileExtension));
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
if ((model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool) model.Extensions[AzureExtensions.ExternalExtension])
|| model.Name == "Resource" || model.Name == "SubResource")
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(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 AzureRequirementsTemplateModel(serviceClient, this.packageName ?? this.sdkName, this.ImplementationFileExtension, this.Settings.Namespace),
};
await Write(requirementsTemplate, RubyCodeNamer.UnderscoreCase(this.packageName ?? this.sdkName) + ImplementationFileExtension);
// Version File
if(this.packageVersion != null)
{
var versionTemplate = new VersionTemplate
{
Model = new VersionTemplateModel(packageVersion),
};
await Write(versionTemplate, Path.Combine(sdkPath, "version" + ImplementationFileExtension));
}
// Module Definition File
if(Settings.Namespace != null)
{
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)
{
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient, InternalConstructors),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
if (serviceClient.Methods.Any(m => m.Group == null))
{
var extensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, null, SyncMethods),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
}
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient, InternalConstructors),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new AzureExtensionsTemplateModel(serviceClient, group, SyncMethods),
};
await Write(operationExtensionsTemplate, operationExtensionsTemplate.Model.ExtensionName + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool) model.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(model),
};
await Write(modelTemplate, Path.Combine(Settings.ModelsName, model.Name + ".cs"));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine(Settings.ModelsName, enumTemplate.Model.TypeDefinitionName + ".cs"));
}
// Page class
foreach (var pageClass in pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new PageTemplateModel(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value),
};
await Write(pageTemplate, Path.Combine(Settings.ModelsName, pageTemplate.Model.TypeDefinitionName + ".cs"));
}
// Exceptions
foreach (var exceptionType in serviceClient.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType),
};
await Write(exceptionTemplate, Path.Combine(Settings.ModelsName, exceptionTemplate.Model.ExceptionTypeDefinitionName + ".cs"));
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient">The service client.</param>
/// <returns>Async tasks which generates SDK files.</returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new AzureServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(serviceClient.Name) + ImplementationFileExtension));
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate
{
Model = new AzureMethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, Path.Combine(sdkPath, RubyCodeNamer.UnderscoreCase(operationsTemplate.Model.MethodGroupName) + ImplementationFileExtension));
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
if (model.Extensions.ContainsKey(AzureCodeGenerator.ExternalExtension) || model.Extensions.ContainsKey(AzureCodeGenerator.AzureResourceExtension))
{
continue;
}
var modelTemplate = new ModelTemplate
{
Model = new AzureModelTemplateModel(model),
};
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 AzureRequirementsTemplateModel(serviceClient, sdkName, this.ImplementationFileExtension),
};
await Write(requirementsTemplate,
RubyCodeNamer.UnderscoreCase(sdkName) + 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
if (serviceClient.Methods.Any(m => m.Group == null))
{
var extensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, null, SyncMethods),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
}
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new ServiceClientTemplateModel(serviceClient, InternalConstructors),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, group, SyncMethods),
};
await Write(operationExtensionsTemplate, group + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes.Concat(serviceClient.HeaderTypes))
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(model),
};
await Write(modelTemplate, Path.Combine(Settings.ModelsName, model.Name + ".cs"));
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, Path.Combine(Settings.ModelsName, enumTemplate.Model.TypeDefinitionName + ".cs"));
}
// Exception
foreach (var exceptionType in serviceClient.ErrorTypes)
{
var exceptionTemplate = new ExceptionTemplate
{
Model = new ModelTemplateModel(exceptionType),
};
await Write(exceptionTemplate, Path.Combine(Settings.ModelsName, exceptionTemplate.Model.ExceptionTypeDefinitionName + ".cs"));
}
}
/// <summary>
/// Generate Python client code for given ServiceClient.
/// </summary>
/// <param name="cm"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelPya;
if (codeModel == null)
{
throw new Exception("CodeModel is not a Python Azure 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 AzureServiceClientTemplate { 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
var models = codeModel.ModelTemplateModels.Where(each => !each.Extensions.ContainsKey(AzureExtensions.ExternalExtension));
if (models.Any())
{
var modelInitTemplate = new AzureModelInitTemplate
{
Model = codeModel
};
await Write(modelInitTemplate, Path.Combine(codeModel.PackageName, "models", "__init__.py"));
foreach (var modelType in models)
{
var modelTemplate = new ModelTemplate { Model = modelType };
await Write(modelTemplate, Path.Combine(codeModel.PackageName, "models", 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 AzureMethodGroupTemplate
{
Model = methodGroupModel as MethodGroupPya
};
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"));
}
// Page class
foreach (var pageModel in codeModel.PageModels)
{
var pageTemplate = new PageTemplate
{
Model = pageModel
};
await Write(pageTemplate, Path.Combine(codeModel.PackageName, "models", pageModel.TypeDefinitionName.ToPythonCase() + ".py"));
}
}
/// <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 Python client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
var serviceClientTemplateModel = new AzureServiceClientTemplateModel(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(serviceClient.Name.ToPythonCase(), "__init__.py"));
var serviceClientTemplate = new AzureServiceClientTemplate
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "api_client.py"));
//Models
if (serviceClientTemplateModel.ModelTemplateModels.Any())
{
var modelInitTemplate = new AzureModelInitTemplate
{
Model = new AzureModelInitTemplateModel(serviceClient, pageModels.Select(t => t.TypeDefinitionName))
};
await Write(modelInitTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "models", "__init__.py"));
foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "models", modelType.Name.ToPythonCase() + ".py"));
}
}
//MethodGroups
if (serviceClientTemplateModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupInitTemplate
{
Model = serviceClientTemplateModel
};
await Write(methodGroupIndexTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "operations", "__init__.py"));
foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels)
{
var methodGroupTemplate = new AzureMethodGroupTemplate
{
Model = methodGroupModel as AzureMethodGroupTemplateModel
};
await Write(methodGroupTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "operations", methodGroupModel.MethodGroupType.ToPythonCase() + ".py"));
}
}
// Enums
if (serviceClient.EnumTypes.Any())
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(serviceClient.EnumTypes),
};
await Write(enumTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "models", "enums.py"));
}
// Page class
foreach (var pageModel in pageModels)
{
var pageTemplate = new PageTemplate
{
Model = pageModel
};
await Write(pageTemplate, Path.Combine(serviceClient.Name.ToPythonCase(), "models", pageModel.TypeDefinitionName.ToPythonCase() + ".py"));
}
}
public static EnumTemplate AddValue(this EnumTemplate enumTemplate, string name, int?value = null)
{
enumTemplate.Values.Add(new EnumValueTemplate(name, Code.Instance.Number(value ?? enumTemplate.Values.Count)));
return(enumTemplate);
}
/// <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));
}
}
public static UsingTemplate ToUsing(this EnumTemplate enumTemplate)
{
return(new UsingTemplate(enumTemplate.Namespace.Name, enumTemplate.Name, enumTemplate.Namespace.File.RelativePath));
}
public async Task GenerateFileAsync(
string input,
string output,
bool unuseUnityAttr,
string @namespace,
string conditionalSymbol)
{
// Prepare args
var namespaceDot = string.IsNullOrWhiteSpace(@namespace) ? string.Empty : @namespace + ".";
var conditionalSymbols = conditionalSymbol?.Split(',') ?? Array.Empty <string>();
// Generator Start...
var sw = Stopwatch.StartNew();
logger("Project Compilation Start:" + input);
var collector = new MethodCollector(input, conditionalSymbols, logger);
logger("Project Compilation Complete:" + sw.Elapsed.ToString());
sw.Restart();
logger("Method Collect Start");
var definitions = collector.CollectServiceInterface();
var hubDefinitions = collector.CollectHubInterface();
GenericSerializationInfo[] genericInfos;
EnumSerializationInfo[] enumInfos;
ExtractResolverInfo(definitions, out genericInfos, out enumInfos);
ExtractResolverInfo(hubDefinitions.Select(x => x.hubDefinition).ToArray(), out var genericInfos2, out var enumInfos2);
ExtractResolverInfo(hubDefinitions.Select(x => x.receiverDefintion).ToArray(), out var genericInfos3, out var enumInfos3);
enumInfos = enumInfos.Concat(enumInfos2).Concat(enumInfos3).Distinct().OrderBy(x => x.FullName).ToArray();
genericInfos = genericInfos.Concat(genericInfos2).Concat(genericInfos3).Distinct().OrderBy(x => x.FullName).ToArray();
logger("Method Collect Complete:" + sw.Elapsed.ToString());
logger("Output Generation Start");
sw.Restart();
var resolverTemplate = new ResolverTemplate()
{
Namespace = namespaceDot + "Resolvers",
FormatterNamespace = namespaceDot + "Formatters",
ResolverName = "MagicOnionResolver",
registerInfos = genericInfos.OrderBy(x => x.FullName).Cast <IResolverRegisterInfo>().Concat(enumInfos.OrderBy(x => x.FullName)).ToArray()
};
var registerTemplate = new RegisterTemplate
{
Namespace = @namespace,
Interfaces = definitions.Where(x => x.IsServiceDefinition).ToArray(),
HubInterfaces = hubDefinitions,
UnuseUnityAttribute = unuseUnityAttr
};
if (Path.GetExtension(output) == ".cs")
{
var enumTemplates = enumInfos.GroupBy(x => x.Namespace)
.OrderBy(x => x.Key)
.Select(x => new EnumTemplate()
{
Namespace = namespaceDot + "Formatters",
enumSerializationInfos = x.ToArray()
})
.ToArray();
var texts = definitions
.GroupBy(x => x.Namespace)
.OrderBy(x => x.Key)
.Select(x => new CodeTemplate()
{
Namespace = x.Key,
Interfaces = x.ToArray()
})
.ToArray();
var hubTexts = hubDefinitions
.GroupBy(x => x.hubDefinition.Namespace)
.OrderBy(x => x.Key)
.Select(x => new HubTemplate()
{
Namespace = x.Key,
Interfaces = x.ToArray()
})
.ToArray();
var sb = new StringBuilder();
sb.AppendLine("// <auto-generated />");
sb.AppendLine(registerTemplate.TransformText());
sb.AppendLine(resolverTemplate.TransformText());
foreach (var item in enumTemplates)
{
sb.AppendLine(item.TransformText());
}
foreach (var item in texts)
{
sb.AppendLine(item.TransformText());
}
foreach (var item in hubTexts)
{
sb.AppendLine(item.TransformText());
}
Output(output, sb.ToString());
}
else
{
Output(NormalizePath(output, registerTemplate.Namespace, "MagicOnionInitializer"), WithAutoGenerated(registerTemplate.TransformText()));
Output(NormalizePath(output, resolverTemplate.Namespace, resolverTemplate.ResolverName), WithAutoGenerated(resolverTemplate.TransformText()));
foreach (var enumTemplate in enumInfos)
{
var x = new EnumTemplate()
{
Namespace = namespaceDot + "Formatters",
enumSerializationInfos = new[] { enumTemplate }
};
Output(NormalizePath(output, x.Namespace, enumTemplate.Name + "Formatter"), WithAutoGenerated(x.TransformText()));
}
foreach (var serviceClient in definitions)
{
var x = new CodeTemplate()
{
Namespace = serviceClient.Namespace,
Interfaces = new[] { serviceClient }
};
Output(NormalizePath(output, serviceClient.Namespace, serviceClient.ClientName), WithAutoGenerated(x.TransformText()));
}
foreach (var hub in hubDefinitions)
{
var x = new HubTemplate()
{
Namespace = hub.hubDefinition.Namespace,
Interfaces = new[] { hub }
};
Output(NormalizePath(output, hub.hubDefinition.Namespace, hub.hubDefinition.ClientName), WithAutoGenerated(x.TransformText()));
}
}
if (definitions.Length == 0 && hubDefinitions.Length == 0)
{
logger("Generated result is empty, unexpected result?");
}
logger("Output Generation Complete:" + sw.Elapsed.ToString());
}
/// <summary>
/// Generates Ruby code for Azure service client.
/// </summary>
/// <param name="cm">The code model.</param>
/// <returns>Async tasks which generates SDK files.</returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelRba;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a Azure Ruby code model.");
}
// Service client
var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel };
await Write(serviceClientTemplate, Path.Combine(GeneratorSettingsRba.Instance.sdkPath, CodeNamer.UnderscoreCase(codeModel.Name) + ImplementationFileExtension));
// Operations
foreach (MethodGroupRba group in codeModel.Operations.Where(each => !each.IsCodeModelMethodGroup))
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate { Model = group };
await Write(operationsTemplate, Path.Combine(GeneratorSettingsRba.Instance.sdkPath, CodeNamer.UnderscoreCase(operationsTemplate.Model.TypeName) + ImplementationFileExtension));
}
// Models
foreach (CompositeTypeRba model in codeModel.ModelTypes)
{
if ((model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)model.Extensions[AzureExtensions.ExternalExtension])
|| model.Name == "Resource" || model.Name == "SubResource")
{
continue;
}
if( codeModel.pageModels.Any( each => each.Name.EqualsIgnoreCase(model.Name ) ) )
{
// Skip, handled in the .pageModels section below.
continue;
}
var modelTemplate = new ModelTemplate { Model = model };
await Write(modelTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(model.Name) + ImplementationFileExtension));
}
// Paged Models
foreach (var pageModel in codeModel.pageModels)
{
var pageTemplate = new PageModelTemplate { Model = pageModel };
await Write(pageTemplate, Path.Combine(GeneratorSettingsRb.Instance.modelsPath, CodeNamer.UnderscoreCase(pageModel.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 RequirementsRba(codeModel, this)};
await Write(requirementsTemplate, CodeNamer.UnderscoreCase(GeneratorSettingsRb.Instance.packageName ?? GeneratorSettingsRb.Instance.sdkName) + ImplementationFileExtension);
// Version File
if (GeneratorSettingsRb.Instance.packageVersion != null)
{
var versionTemplate = new VersionTemplate { Model = GeneratorSettingsRb.Instance.packageVersion };
await Write(versionTemplate, Path.Combine(GeneratorSettingsRb.Instance.sdkPath, "version" + ImplementationFileExtension));
}
// Module Definition File
if (Settings.Instance.Namespace != null)
{
var modTemplate = new ModuleDefinitionTemplate { Model = GeneratorSettingsRb.Instance.ModuleDeclarations };
await Write(modTemplate, Path.Combine(GeneratorSettingsRb.Instance.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)
{
// 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 C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var packagePath = $"src/main/java/{Settings.Instance.Namespace.ToLower().Replace('.', '/')}";
// get Azure Java specific codeModel
var codeModel = cm as CodeModelJvaf;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a Azure Java Fluent CodeModel");
}
SegmentFluentMethodGroups innerMGroupToFluentMGroup = null;
if (true == AutoRest.Core.Settings.Instance.Host?.GetValue <bool?>("generate-interface").Result)
{
var idParsingUtilsTemplate = new IdParsingUtilsTemplate {
Model = codeModel
};
await Write(idParsingUtilsTemplate, $"{packagePath}/implementation/IdParsingUtils{ImplementationFileExtension}");
innerMGroupToFluentMGroup = SegmentFluentMethodGroups.InnerMethodGroupToSegmentFluentMethodGroups(codeModel);
#region Produce all method group interfaces
//
foreach (IFluentMethodGroup group in innerMGroupToFluentMGroup.Select(m => m.Value.PrunedMethodGroup))
{
var methodGroupInterfaceTemplate = new FluentMethodGroupInterfaceTemplate {
Model = new ClientFluentMethodGroupInterface(group)
};
await Write(methodGroupInterfaceTemplate, $"{packagePath}/{group.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}");
}
//
#endregion
#region Produce all method group implementation
//
innerMGroupToFluentMGroup.Select(m => m.Value).ForEach(async list =>
{
var prunedGroup = list.PrunedMethodGroup;
if (prunedGroup.Type == MethodGroupType.GroupableTopLevel)
{
ClientFluentGroupableMethodGroupImpl groupImplModel = new ClientFluentGroupableMethodGroupImpl(prunedGroup);
var groupImplTemplate = new GroupableMethodGroupImplTemplate {
Model = groupImplModel
};
await Write(groupImplTemplate, $"{packagePath}/implementation/{groupImplModel.JavaClassName.ToPascalCase()}{ImplementationFileExtension}");
}
else if (prunedGroup.Type == MethodGroupType.NonGroupableTopLevel)
{
ClientFluentNonGroupableTopLevelMethodGroupImpl groupImplModel = new ClientFluentNonGroupableTopLevelMethodGroupImpl(prunedGroup);
var groupImplTemplate = new NonGroupableTopLevelMethodGroupImplTemplate {
Model = groupImplModel
};
await Write(groupImplTemplate, $"{packagePath}/implementation/{groupImplModel.JavaClassName.ToPascalCase()}{ImplementationFileExtension}");
}
else if (prunedGroup.Type == MethodGroupType.Nested)
{
ClientFluentNestedMethodGroupImpl groupImplModel = new ClientFluentNestedMethodGroupImpl(prunedGroup);
var groupImplTemplate = new NestedMethodGroupImplTemplate {
Model = groupImplModel
};
await Write(groupImplTemplate, $"{packagePath}/implementation/{groupImplModel.JavaClassName.ToPascalCase()}{ImplementationFileExtension}");
}
else if (prunedGroup.Type == MethodGroupType.ActionsOnly)
{
var groupImplModel = new ClientFluentActionsOnlyMethodGroupImpl(prunedGroup);
var groupImplTemplate = new ActionsOnlyMethodGroupImplTemplate {
Model = groupImplModel
};
await Write(groupImplTemplate, $"{packagePath}/implementation/{groupImplModel.JavaClassName.ToPascalCase()}{ImplementationFileExtension}");
}
});
//
#endregion
#region Produce readonly model interface & impl
//
foreach (ClientFluentReadOnlyModelInterface fluentModel in innerMGroupToFluentMGroup.ReadonlyFluentModels)
{
var modelInterfaceTemplate = new ReadOnlyModelInterfaceTemplate {
Model = fluentModel
};
await Write(modelInterfaceTemplate, $"{packagePath}/{fluentModel.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}");
//
var modelImplTemplate = new ReadOnlyModelImplTemplate {
Model = fluentModel.Impl
};
await Write(modelImplTemplate, $"{packagePath}/implementation/{fluentModel.Impl.JavaClassName.ToPascalCase()}{ImplementationFileExtension}");
// No specific method group for readonly models these models are shared between other type of method groups [Groupable, no-Groupable-top-level and nested]
}
#endregion
#region Produce nested model interface & impl
//
foreach (ClientFluentNestedModelInterface fluentModel in innerMGroupToFluentMGroup.NestedFluentModels)
{
var modelInterfaceTemplate = new NestedModelInterfaceTemplate {
Model = fluentModel
};
await Write(modelInterfaceTemplate, $"{packagePath}/{fluentModel.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}");
//
var modelImplTemplate = new NestedModelImplTemplate {
Model = fluentModel.Impl
};
await Write(modelImplTemplate, $"{packagePath}/implementation/{fluentModel.Impl.JavaClassName.ToPascalCase()}{ImplementationFileExtension}");
}
#endregion
#region Produce groupable model interface & impl
//
foreach (ClientFluentGroupableModelInterface fluentModel in innerMGroupToFluentMGroup.GroupableFluentModels)
{
var modelInterfaceTemplate = new GroupableModelInterfaceTemplate {
Model = fluentModel
};
await Write(modelInterfaceTemplate, $"{packagePath}/{fluentModel.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}");
var modelImplTemplate = new GroupableModelImplTemplate {
Model = fluentModel.Impl
};
await Write(modelImplTemplate, $"{packagePath}/implementation/{fluentModel.Impl.JavaClassName.ToPascalCase()}{ImplementationFileExtension}");
}
#endregion
#region Produce non-groupable top-level model interface & impl
foreach (ClientFluentNonGroupableTopLevelModelInterface fluentModel in innerMGroupToFluentMGroup.NonGroupableTopLevelFluentModels)
{
var modelInterfaceTemplate = new NonGroupableTopLevelModelInterfaceTemplate {
Model = fluentModel
};
await Write(modelInterfaceTemplate, $"{packagePath}/{fluentModel.JavaInterfaceName.ToPascalCase()}{ImplementationFileExtension}");
var modelImplTemplate = new NonGroupableTopLevelModelImplTemplate {
Model = fluentModel.Impl
};
await Write(modelImplTemplate, $"{packagePath}/implementation/{fluentModel.Impl.JavaClassName.ToPascalCase()}{ImplementationFileExtension}");
}
#endregion
if (true == AutoRest.Core.Settings.Instance.Host?.GetValue <bool?>("generate-test").Result)
{
var packageTestPath = $"src/test/java/{Settings.Instance.Namespace.ToLower().Replace('.', '/')}";
var testModel = new TestModel(codeModel);
await Write(new TestTemplate { Model = testModel }, $"{packageTestPath}/{testModel.ClassName}Test{ImplementationFileExtension}");
}
}
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, $"{packagePath}/implementation/{codeModel.Name.ToPascalCase()}Impl{ImplementationFileExtension}");
// operations
foreach (MethodGroupJvaf methodGroup in codeModel.AllOperations)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate {
Model = methodGroup
};
await Write(operationsTemplate, $"{packagePath}/implementation/{methodGroup.TypeName.ToPascalCase()}Inner{ImplementationFileExtension}");
}
//Models
foreach (CompositeTypeJvaf modelType in cm.ModelTypes.Concat(codeModel.HeaderTypes))
{
if (modelType.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)modelType.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
if (modelType.IsResource)
{
continue;
}
var modelTemplate = new ModelTemplate {
Model = modelType
};
await Write(modelTemplate, $"{packagePath}/{modelType.ModelsPackage.Trim('.')}/{modelType.Name.ToPascalCase()}{ImplementationFileExtension}");
}
//Enums
foreach (EnumTypeJvaf enumType in cm.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
await Write(enumTemplate, $"{packagePath}/{enumType.ModelsPackage.Trim('.')}/{enumTemplate.Model.Name.ToPascalCase()}{ImplementationFileExtension}");
}
// Page class
foreach (var pageClass in codeModel.pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new PageJvaf(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value),
};
await Write(pageTemplate, $"{packagePath}/implementation/{pageTemplate.Model.TypeDefinitionName.ToPascalCase()}{ImplementationFileExtension}");
}
// Exceptions
foreach (CompositeTypeJv exceptionType in codeModel.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate {
Model = exceptionType
};
await Write(exceptionTemplate, $"{packagePath}/{exceptionType.ModelsPackage.Trim('.')}/{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}");
}
// package-info.java
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(cm)
}, $"{packagePath}/{_packageInfoFileName}");
await Write(new PackageInfoTemplate
{
Model = new PackageInfoTemplateModel(cm, "implementation")
}, $"{packagePath}/implementation/{_packageInfoFileName}");
if (true == AutoRest.Core.Settings.Instance.Host?.GetValue <bool?>("regenerate-manager").Result)
{
ServiceManagerModel serviceManagerModel = new ServiceManagerModel(codeModel, innerMGroupToFluentMGroup);
// Manager
await Write(
new AzureFluentServiceManagerTemplate { Model = serviceManagerModel },
$"{packagePath}/implementation/{serviceManagerModel.ManagerName}{ImplementationFileExtension}");
// POM
await Write(new AzureFluentPomTemplate { Model = codeModel }, "pom.xml");
}
}
public async Task GenerateFileAsync(
string input,
string output,
string conditionalSymbol,
string resolverName,
string @namespace,
bool useMapMode,
string multipleIfDirectiveOutputSymbols)
{
var namespaceDot = string.IsNullOrWhiteSpace(@namespace) ? string.Empty : @namespace + ".";
var conditionalSymbols = conditionalSymbol?.Split(',') ?? Array.Empty <string>();
var multipleOutputSymbols = multipleIfDirectiveOutputSymbols?.Split(',') ?? Array.Empty <string>();
var sw = Stopwatch.StartNew();
foreach (var multioutSymbol in multipleOutputSymbols.Length == 0 ? new[] { string.Empty } : multipleOutputSymbols)
{
logger("Project Compilation Start:" + input);
var compilation = (Path.GetExtension(input) == ".csproj")
? await MessagePackCompilation.CreateFromProjectAsync(input.Split(','), conditionalSymbols.Concat(new[] { multioutSymbol }).ToArray(), cancellationToken)
.ConfigureAwait(false) : await MessagePackCompilation.CreateFromDirectoryAsync(input, conditionalSymbols.Concat(new[] { multioutSymbol }).ToArray(), cancellationToken).ConfigureAwait(false);
var collector = new TypeCollector(compilation, true, useMapMode, x => Console.WriteLine(x));
logger("Project Compilation Complete:" + sw.Elapsed.ToString());
sw.Restart();
logger("Method Collect Start");
var(objectInfo, enumInfo, genericInfo, unionInfo) = collector.Collect();
logger("Method Collect Complete:" + sw.Elapsed.ToString());
logger("Output Generation Start");
sw.Restart();
if (Path.GetExtension(output) == ".cs")
{
// SingleFile Output
var objectFormatterTemplates = objectInfo
.GroupBy(x => x.Namespace)
.Select(x => new FormatterTemplate()
{
Namespace = namespaceDot + "Formatters" + ((x.Key == null) ? string.Empty : "." + x.Key),
ObjectSerializationInfos = x.ToArray(),
})
.ToArray();
var enumFormatterTemplates = enumInfo
.GroupBy(x => x.Namespace)
.Select(x => new EnumTemplate()
{
Namespace = namespaceDot + "Formatters" + ((x.Key == null) ? string.Empty : "." + x.Key),
EnumSerializationInfos = x.ToArray(),
})
.ToArray();
var unionFormatterTemplates = unionInfo
.GroupBy(x => x.Namespace)
.Select(x => new UnionTemplate()
{
Namespace = namespaceDot + "Formatters" + ((x.Key == null) ? string.Empty : "." + x.Key),
UnionSerializationInfos = x.ToArray(),
})
.ToArray();
var resolverTemplate = new ResolverTemplate()
{
Namespace = namespaceDot + "Resolvers",
FormatterNamespace = namespaceDot + "Formatters",
ResolverName = resolverName,
RegisterInfos = genericInfo.Cast <IResolverRegisterInfo>().Concat(enumInfo).Concat(unionInfo).Concat(objectInfo).ToArray(),
};
var sb = new StringBuilder();
sb.AppendLine(resolverTemplate.TransformText());
sb.AppendLine();
foreach (var item in enumFormatterTemplates)
{
var text = item.TransformText();
sb.AppendLine(text);
}
sb.AppendLine();
foreach (var item in unionFormatterTemplates)
{
var text = item.TransformText();
sb.AppendLine(text);
}
sb.AppendLine();
foreach (var item in objectFormatterTemplates)
{
var text = item.TransformText();
sb.AppendLine(text);
}
if (multioutSymbol == string.Empty)
{
await OutputAsync(output, sb.ToString(), cancellationToken).ConfigureAwait(false);
}
else
{
var fname = Path.GetFileNameWithoutExtension(output) + "." + MultiSymbolToSafeFilePath(multioutSymbol) + ".cs";
var text = $"#if {multioutSymbol}" + Environment.NewLine + sb.ToString() + Environment.NewLine + "#endif";
await OutputAsync(Path.Combine(Path.GetDirectoryName(output), fname), text, cancellationToken).ConfigureAwait(false);
}
}
else
{
// Multiple File output
foreach (var x in objectInfo)
{
var template = new FormatterTemplate()
{
Namespace = namespaceDot + "Formatters" + ((x.Namespace == null) ? string.Empty : "." + x.Namespace),
ObjectSerializationInfos = new[] { x },
};
var text = template.TransformText();
await OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text, cancellationToken).ConfigureAwait(false);
}
foreach (var x in enumInfo)
{
var template = new EnumTemplate()
{
Namespace = namespaceDot + "Formatters" + ((x.Namespace == null) ? string.Empty : "." + x.Namespace),
EnumSerializationInfos = new[] { x },
};
var text = template.TransformText();
await OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text, cancellationToken).ConfigureAwait(false);
}
foreach (var x in unionInfo)
{
var template = new UnionTemplate()
{
Namespace = namespaceDot + "Formatters" + ((x.Namespace == null) ? string.Empty : "." + x.Namespace),
UnionSerializationInfos = new[] { x },
};
var text = template.TransformText();
await OutputToDirAsync(output, template.Namespace, x.Name + "Formatter", multioutSymbol, text, cancellationToken).ConfigureAwait(false);
}
var resolverTemplate = new ResolverTemplate()
{
Namespace = namespaceDot + "Resolvers",
FormatterNamespace = namespaceDot + "Formatters",
ResolverName = resolverName,
RegisterInfos = genericInfo.Cast <IResolverRegisterInfo>().Concat(enumInfo).Concat(unionInfo).Concat(objectInfo).ToArray(),
};
await OutputToDirAsync(output, resolverTemplate.Namespace, resolverTemplate.ResolverName, multioutSymbol, resolverTemplate.TransformText(), cancellationToken).ConfigureAwait(false);
}
}
logger("Output Generation Complete:" + sw.Elapsed.ToString());
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
// get Azure Java specific codeModel
var codeModel = cm as CodeModelJvaf;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a Azure Java Fluent CodeModel");
}
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate {
Model = codeModel
};
await Write(serviceClientTemplate, $"{Path.Combine("implementation", codeModel.Name.ToPascalCase() + "Impl")}{ImplementationFileExtension}");
// operations
foreach (MethodGroupJvaf methodGroup in codeModel.AllOperations)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate {
Model = methodGroup
};
await Write(operationsTemplate, $"{Path.Combine("implementation", methodGroup.TypeName.ToPascalCase())}Inner{ImplementationFileExtension}");
}
//Models
foreach (CompositeTypeJvaf modelType in cm.ModelTypes.Concat(codeModel.HeaderTypes))
{
if (modelType.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)modelType.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
if (modelType.IsResource)
{
continue;
}
var modelTemplate = new ModelTemplate {
Model = modelType
};
await Write(modelTemplate, Path.Combine(modelType.ModelsPackage.Trim('.'), $"{modelType.Name.ToPascalCase()}{ImplementationFileExtension}"));
}
//Enums
foreach (EnumTypeJvaf enumType in cm.EnumTypes)
{
var enumTemplate = new EnumTemplate {
Model = enumType
};
await Write(enumTemplate, Path.Combine(enumType.ModelsPackage.Trim('.'), $"{enumTemplate.Model.Name.ToPascalCase()}{ImplementationFileExtension}"));
}
// Page class
foreach (var pageClass in codeModel.pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new PageJvaf(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value),
};
await Write(pageTemplate, Path.Combine("implementation", $"{pageTemplate.Model.TypeDefinitionName.ToPascalCase()}{ImplementationFileExtension}"));
}
// Exceptions
foreach (CompositeTypeJv exceptionType in codeModel.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate {
Model = exceptionType
};
await Write(exceptionTemplate, Path.Combine(exceptionType.ModelsPackage.Trim('.'), $"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{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));
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="cm"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelCsa;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a Azure c# CodeModel");
}
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel };
await Write(serviceClientTemplate, $"{codeModel.Name}{ImplementationFileExtension}");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = codeModel };
await Write(serviceClientInterfaceTemplate, "I" + codeModel.Name + ImplementationFileExtension);
// Operations
foreach (MethodGroupCs group in codeModel.Operations)
{
if (!group.IsCodeModelMethodGroup)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate { Model = group };
await Write(operationsTemplate, operationsTemplate.Model.TypeName + ImplementationFileExtension);
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = group };
await Write(operationsInterfaceTemplate,
$"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}");
}
var operationExtensionsTemplate = new ExtensionsTemplate { Model = group };
await Write(operationExtensionsTemplate,
$"{group.ExtensionTypeName}Extensions{ImplementationFileExtension}");
}
// Models
foreach (CompositeTypeCs model in codeModel.ModelTypes.Concat(codeModel.HeaderTypes))
{
if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)model.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
if (model.IsResource())
{
continue;
}
var modelTemplate = new ModelTemplate { Model = model };
await Write(modelTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{model.Name}{ImplementationFileExtension}"));
}
// Enums
foreach (EnumTypeCs enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate { Model = enumType };
await Write(enumTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{enumTemplate.Model.Name}{ImplementationFileExtension}"));
}
// Page class
foreach (var pageClass in codeModel.pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new Page(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value)
};
await Write(pageTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{pageTemplate.Model.TypeDefinitionName}{ImplementationFileExtension}"));
}
// Exceptions
foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate { Model = exceptionType };
await Write(exceptionTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}"));
}
}
/// <summary>
/// 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>
/// 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"));
}
}
