/// <summary>
/// 预览 Model
/// </summary>
/// <param name="tableName"></param>
private void showModelPreview(string tableName)
{
//2. 获取表名
//tableName = Right_listBox.Items[0].ToString();
//3. 获取“其他项”里面的信息
//3.1 获取命名空间
string ns = namespace_textBox.Text.Trim(); //命名空间
//3.1.1 判断“命名空间是否不为空”
if (string.IsNullOrEmpty(ns))
{
MessageBox.Show("请输入命名空间！");
return;
}
//3.2 获取表前缀
string tablePrefix = table_prefix_textBox.Text.Trim();
//3.2.1 去掉前缀
string className = tableName.Replace(tablePrefix, "");
//3.2.2 将类名第一个字母进行大写
className = className.Substring(0, 1).ToUpper() + className.Substring(1);
//3.3 获取作者信息
string author = author_textBox.Text.Trim();
//4. 获取连接字符串
string connStr = getConnstr();
//5. 获取 Model 模板代码
preview_textEditorControl.Text = ModelTemplate.GetModelTemplate(ns, tableName, author, className, connStr);
}
/// <summary>
/// Generates TypeScript code and outputs it in the file system.
/// </summary>
/// <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.");
}
try
{
var modelsBinder = new ModelsModelBinder();
var clientModelsBinder = new ClientGroupsModelBinder();
var models = modelsBinder.Bind(codeModel);
var clientModels = clientModelsBinder.Bind(codeModel);
var modelTemplate = new ModelTemplate {
Model = models
};
await Write(modelTemplate, "model.ts");
var clientTemplate = new ClientTemplate {
Model = clientModels
};
await Write(clientTemplate, "api.ts");
}
catch (Exception ex)
{
throw;
}
}
/// <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
/// </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"));
}
}
}
protected virtual async Task GenerateServerSideCode(CodeModelCs codeModel)
{
foreach (string methodGrp in codeModel.MethodGroupNames)
{
using (NewContext)
{
codeModel.Name = methodGrp;
// Service server
var serviceControllerTemplate = new AutoRest.CSharp.vanilla.Templates.Rest.Server.WcfServiceInterfaceTemplate {
Model = codeModel
};
await Write(serviceControllerTemplate, $"{GeneratedSourcesBaseFolder}{codeModel.Name}{ImplementationFileExtension}");
}
}
// Models
foreach (CompositeTypeCs model in codeModel.ModelTypes.Union(codeModel.HeaderTypes))
{
if (true == model.Extensions.Get <bool>(SwaggerExtensions.ExternalExtension))
{
continue;
}
var modelTemplate = new ModelTemplate {
Model = model
};
await Write(modelTemplate, $"{GeneratedSourcesBaseFolder}{FolderModels}/{model.Name}{ImplementationFileExtension}");
}
}
public Model(string path)
{
Parts = new List <ModelPart>();
FilePath = path;
using (var stream = new FileStream(path, FileMode.Open))
{
CheckHeader(stream);
Type = BitConverter.ToInt32(stream.ReadBytes(4));
Template = new ModelTemplate(stream);
stream.ReadBytes(10);
MountPoints = new MountPoints(stream);
Lights = new Lights(stream);
stream.ReadBytes(64);
stream.ReadBytes(488);
UnknownVal1 = BitConverter.ToInt16(stream.ReadBytes(2));
UnknownVal2 = BitConverter.ToInt16(stream.ReadBytes(2));
UnknownVal3 = BitConverter.ToInt16(stream.ReadBytes(2));
UnknownVal4 = BitConverter.ToInt16(stream.ReadBytes(2));
UnknownVal5 = BitConverter.ToInt16(stream.ReadBytes(4));
if (Type != 0)
{
throw new NotSupportedException("Not supported mesh format");
}
Parts = GetParts(stream).ToList();
PartsTree = GetPartsTree(Parts);
}
}
protected async Task GenerateModelJs(CompositeTypeJs model, GeneratorSettingsJs generatorSettings)
{
var modelTemplate = new ModelTemplate {
Model = model
};
await Write(modelTemplate, GetModelSourceCodeFilePath(generatorSettings, model.NameAsFileName.ToCamelCase() + ".js")).ConfigureAwait(false);
}
/// <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 static void GenerateModel(string tableName)
{
var fieldList = generateDal.GetFieldList(tableName);
var tableModel = generateDal.GetTableList().Single(o => o.Name == tableName);
ModelTemplate modelTemplate = new ModelTemplate(fieldList, tableModel);
String contentModel = modelTemplate.TransformText();
System.IO.File.WriteAllText(Utility.FileHelper.PathExists(Config.BusinessEntitiesPath, tableName, Enums.GenerateType.Model), contentModel, Encoding.UTF8);
}
/// <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}"));
}
}
public void GenerateDomainProject(DomainDataService dataService, string outputFolder)
{
outputFolder = Path.Combine(outputFolder, $"{dataService.Solution.NamespacePrefix}.{dataService.Name}.Domain");
var constantsFolder = Path.Combine(outputFolder, "Constants");
var modelsFolder = Path.Combine(outputFolder, "Models");
var metadataFolder = Path.Combine(outputFolder, "Metadata");
ReplaceDirectories(constantsFolder, modelsFolder, metadataFolder);
var session = new Dictionary <string, object>();
session.Add("DomainDataService", dataService);
DomainProjectTemplate projectTemplate = new DomainProjectTemplate();
projectTemplate.Session = session;
projectTemplate.Initialize();
string content = projectTemplate.TransformText();
File.WriteAllText(Path.Combine(outputFolder, $"{dataService.Solution.NamespacePrefix}.{dataService.Name}.Domain.csproj"), content);
DomainConstantsTemplate constantsTemplate = new DomainConstantsTemplate();
constantsTemplate.Session = session;
constantsTemplate.Initialize();
content = constantsTemplate.TransformText();
File.WriteAllText(Path.Combine(constantsFolder, $"{dataService.Name}Constants.cs"), content);
if (!(dataService.Schemas is null))
{
foreach (var domainObject in dataService.Schemas.SelectMany(s => s.Objects))
{
session["CurrentObject"] = domainObject;
ModelTemplate modelTemplate = new ModelTemplate();
modelTemplate.Session = session;
modelTemplate.Initialize();
content = modelTemplate.TransformText();
File.WriteAllText(Path.Combine(modelsFolder, $"{domainObject.ObjectName}.cs"), content);
MetadataTemplate metadataTemplate = new MetadataTemplate();
metadataTemplate.Session = session;
metadataTemplate.Initialize();
content = metadataTemplate.TransformText();
File.WriteAllText(Path.Combine(metadataFolder, $"{domainObject.ObjectName}Metadata.cs"), content);
}
}
MetadataBundleTemplate bundleTemplate = new MetadataBundleTemplate();
bundleTemplate.Session = session;
bundleTemplate.Initialize();
content = bundleTemplate.TransformText();
File.WriteAllText(Path.Combine(metadataFolder, $"{dataService.Name}MetadataBundle.cs"), content);
}
/// <summary>
/// Inserts category template
/// </summary>
/// <param name="modelTemplate">Category template</param>
public virtual void InsertModelTemplate(ModelTemplate modelTemplate)
{
if (modelTemplate == null)
{
throw new ArgumentNullException("modelTemplate");
}
_modelTemplateRepository.Insert(modelTemplate);
//event notification
_eventPublisher.EntityInserted(modelTemplate);
}
public void RenderEntityFile(List <EntityModel> models)
{
if (!Directory.Exists(_outputPath + "Entity\\" + NormalizeTableName + "\\"))
{
Directory.CreateDirectory(_outputPath + "Entity\\" + NormalizeTableName + "\\");
}
var entityOutputPath = _outputPath + "Entity\\" + NormalizeTableName + "\\" + NormalizeTableName + "Entity.cs";
var modelTemplate = new ModelTemplate(models, NormalizeTableName, _projectName);
var output = modelTemplate.TransformText();
File.WriteAllText(entityOutputPath, output);
}
/// <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 static ModelCollectionContent Postprocess(ModelCollectionContent models)
{
for (int i = 0; i < models._Models.Length; ++i)
{
var srcModel = new ModelTemplate(models, i).CreateInstance();
var bounds = EvaluateBoundingSphere(srcModel, models._SharedMeshes);
var dstModel = models._Models[i];
dstModel.ModelBounds = bounds;
}
return(models);
}
public void It_should_throw_if_model_uses_template_without_name()
{
var template = new ModelTemplate {
TemplateName = "temp1"
};
var model = new Model {
UseTemplate = new YamlTemplateReference()
};
var ex = Assert.Throws <InvalidOperationException>(() => model.ApplyTemplate(template));
Assert.That(ex.Message, Is.EqualTo($"{typeof(Model)} has UseTemplate property but template name is not specified."));
}
/// <summary>
/// Bestätigen der Prüfung. Modell kann zur Graphdatenbank hinzugefügt werden oder es wird nur eine Schablone erstellt.
/// </summary>
private void ClickOnNewTemplate(object sender, RoutedEventArgs e)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.Filter = "IFC-Files (*.ifc)|*.ifc";
string sourceFile = null;
string resultFile = null;
if (openFileDialog.ShowDialog() == true)
{
var filestream = openFileDialog.OpenFile();
LabelShowOpenFile.Content = openFileDialog.FileName;
sourceFile = openFileDialog.FileName;
SourcefilePath = openFileDialog.FileName;
}
if (ExaminerName.Text == "" || ModelName.Text == "" || sourceFile == null || ExaminerName.Text == "Name des Prüfers" || ModelName.Text == "Name des Gebäudemodells")
{
MessageBox.Show("Geben sie Prüfer- und Modellname, sowie die zu prüfende IFC-Datei an. ");
}
else
{
var result = MessageBox.Show("Soll die IFC-Datei in die Graphdatenbank geladen werden?", "", MessageBoxButton.YesNo);
//Hinzufügen des Modells in die Graphdatenbank
if (result == MessageBoxResult.Yes)
{
var parser = new Instance2Neo4jParser
{
SourceLocation = sourceFile,
TargetLocation = resultFile
};
var modelName = "templateModel";
parser.SendToDb(false, modelName, Neo4jAccessData.Uri, Neo4jAccessData.User, Neo4jAccessData.Password);
MessageBox.Show("IFC-Datei wurde in die Graphdatenbank geladen.", "Neue Schablone");
}
//Erstellen der Schablone für das geprüfte Modell
var TemplateModel = new ModelTemplate("templateModel", StoreyRestriction, ExaminationRestriction);
Byte[] bytes = File.ReadAllBytes(sourceFile);
string file = Convert.ToBase64String(bytes);
//Erzeugen einer neuen Genehmigung
Permission = new Permission(ExaminerName.Text, ModelName.Text, TemplateModel.JsonTemplate, file, StoreyRestriction, ExaminationRestriction);
//Aufrufen der nächsten Seite
ComparisonPage comparisonPage = new ComparisonPage(Permission);
this.Content = comparisonPage;
}
}
private void CreateType(Module module, GeneratorType type, string typeFolder)
{
if (type.BaseType == typeof(Enum))
{
// create model.ts file
var modelTemplate = new ModelTemplate(type, Modules);
TransformText(modelTemplate, $"{typeFolder}\\{type.Name.ToLower(cultureInfo)}.ts");
// create service.ts file
var serviceTemplate = new EnumServiceTemplate(type);
TransformText(serviceTemplate, $"{typeFolder}\\{type.Name.ToLower(cultureInfo)}.service.ts");
}
else
{
// create model.ts file
var modelTemplate = new ModelTemplate(type, Modules);
TransformText(modelTemplate, $"{typeFolder}\\{type.Name.ToLower(cultureInfo)}.ts");
// create service.ts file
var serviceTemplate = new ServiceTemplate(type, module.ModuleName);
TransformText(serviceTemplate, $"{typeFolder}\\{type.Name.ToLower(cultureInfo)}.service.ts");
// create listcomponent.ts file
var listComponentTemplate = new ListComponentTemplate(type);
TransformText(listComponentTemplate, $"{typeFolder}\\{type.Name.ToLower(cultureInfo)}-list.component.ts");
// create list html.ts file
var listHtmlTemplate = new ListHtmlTemplate(type, module.ModuleName, module.UIName);
TransformText(listHtmlTemplate, $"{typeFolder}\\{type.Name.ToLower(cultureInfo)}-list.template.html");
// create edit component.ts file
var editComponentTemplate = new EditComponentTemplate(type, module.ModuleName, Modules);
TransformText(editComponentTemplate, $"{typeFolder}\\{type.Name.ToLower(cultureInfo)}-edit.component.ts");
// create edit html.ts file
var editHtmlTemplate = new EditHtmlTemplate(type, module.ModuleName, module.UIName);
TransformText(editHtmlTemplate, $"{typeFolder}\\{type.Name.ToLower(cultureInfo)}-edit.template.html");
// create enum pipe files
var enumProperties = GetEnumProperties(type.Type);
foreach (var pi in enumProperties)
{
var typeName = ExtractTypeName(pi);
var enumModule = SearchTypeInModules(Modules, typeName);
var pipeFolder = $"{OutputFolder}\\src\\app\\core\\pipes";
CreateFolder(pipeFolder);
var enumPipeTemplate = new EnumPipeTemplate(pi, module);
TransformText(enumPipeTemplate, $"{pipeFolder}\\{typeName.ToLower(cultureInfo)}.pipe.ts");
}
}
}
protected void ShowFieldModelList()
{
IList <ModelTemplatesInfo> list = ModelTemplate.GetModelTemplateInfoList(0, 0, ModelType.Content);
this.DropModelTemplate.Items.Clear();
ListItem item = new ListItem("空白内容模型模板", "0");
this.DropModelTemplate.Items.Add(item);
this.DropModelTemplate.AppendDataBoundItems = true;
this.DropModelTemplate.DataSource = list;
this.DropModelTemplate.DataTextField = "TemplateName";
this.DropModelTemplate.DataValueField = "TemplateId";
this.DropModelTemplate.DataBind();
}
public static void Generate(ReaderParameters readerParameters)
{
using (var schemaReader = SchemaReaderProvider.GetReader(readerParameters.ServerType))
{
var connectionString = readerParameters.ConnectionString;
if (readerParameters.UseConnectionStringName)
{
connectionString = ConfigurationManager.ConnectionStrings[readerParameters.ConnectionStringName].ConnectionString;
}
if (schemaReader == null || string.IsNullOrEmpty(connectionString))
{
throw new Exception("Schema reader object or connection ring not valid!");
}
if (string.IsNullOrEmpty(readerParameters.Namespace))
{
readerParameters.Namespace = readerParameters.ServerType.ToString() + ".Models";
}
if (string.IsNullOrEmpty(readerParameters.ModelsLocation))
{
readerParameters.ModelsLocation = readerParameters.ServerType.ToString() + ".Models";
}
var tables = schemaReader.ReadSchema(connectionString);
foreach (var table in tables)
{
var model = new ModelTemplate();
model.Namespace = readerParameters.Namespace;
model.IncludeRelationships = readerParameters.IncludeRelationships;
model.Table = table;
model.Tables = tables;
// get page content
string pageContent = model.TransformText();
if (!Directory.Exists(readerParameters.ModelsLocation))
{
Directory.CreateDirectory(readerParameters.ModelsLocation);
}
// Write model to file
string fileName = table.ClassName + ".cs";
Console.WriteLine(string.Format("Creating file {0} ...", fileName));
File.WriteAllText(Path.Combine(readerParameters.ModelsLocation, fileName), pageContent);
}
}
}
public static Task <GeneratePocoResponse> Generate(GeneratePocoRequest request)
{
return(Task.Run(() =>
{
using (var schemaReader = SchemaReaderProvider.GetReader(request.ServerType))
{
var connectionString = request.ConnectionString;
if (schemaReader == null || string.IsNullOrEmpty(connectionString))
{
return new GeneratePocoResponse();
}
var tables = schemaReader.ReadSchema(connectionString);
if (tables == null || tables.Count <= 0)
{
throw new Exception(string.Format("Empty database or invalid connection string: {0}", connectionString));
}
var fileNames = new List <string>();
foreach (var table in tables)
{
var model = new ModelTemplate();
model.Namespace = request.Namespace;
model.IncludeRelationships = request.IncludeRelationship;
model.Table = table;
model.Tables = tables;
// get page content
string pageContent = model.TransformText();
if (!Directory.Exists(request.FolderLocation))
{
Directory.CreateDirectory(request.FolderLocation);
}
// Write model to file
string fileName = table.ClassName + ".cs";
File.WriteAllText(Path.Combine(request.FolderLocation, fileName), pageContent);
fileNames.Add(fileName);
}
var response = new GeneratePocoResponse();
response.Filenames = fileNames;
return response;
}
}));
}
/// <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"));
}
}
}
public void It_should_allow_parameterless_templates()
{
var template = new ModelTemplate {
Value = "abc", Values = new[] { "def", "ghi" }, TemplateName = "temp1"
};
var model = new Model {
UseTemplate = new YamlTemplateReference {
Name = "temp1"
}, Values = new[] { "custom" }
};
model.ApplyTemplate(template);
Assert.That(model.Value, Is.EqualTo(template.Value));
Assert.That(model.Values, Is.EqualTo(new[] { "custom" }));
}
public void It_should_throw_if_template_does_not_exists()
{
var template = new ModelTemplate {
TemplateName = "temp1"
};
var model = new Model {
UseTemplate = new YamlTemplateReference {
Name = "temp2"
}
};
var ex = Assert.Throws <InvalidOperationException>(() => model.ApplyTemplate(template));
Assert.That(ex.Message, Is.EqualTo($"No template with name '{model.UseTemplate.Name}' has been found."));
}
public void Template_should_be_reusable()
{
var template = new ModelTemplate
{
TemplateName = "template",
TemplateParameters = new[] { "p1", "p2" },
Value = "${p1}${p2}",
Dictionary = new Dictionary <string, Model[]>
{
{ "${p1}", new[] { new Model {
Value = "${p2}"
} } }
}
};
var model1 = new Model
{
UseTemplate = new YamlTemplateReference
{
Name = "template",
Arguments = new Dictionary <string, string> {
{ "p1", "val1" }, { "p2", "val2" }
}
}
};
var model2 = new Model
{
UseTemplate = new YamlTemplateReference
{
Name = "template",
Arguments = new Dictionary <string, string> {
{ "p1", "val3" }, { "p2", "val4" }
}
}
};
model1.ApplyTemplate(template);
model2.ApplyTemplate(template);
Assert.That(model1.Value, Is.EqualTo("val1val2"));
Assert.That(model2.Value, Is.EqualTo("val3val4"));
Assert.That(model1.Dictionary["val1"][0].Value, Is.EqualTo("val2"));
Assert.That(model2.Dictionary["val3"][0].Value, Is.EqualTo("val4"));
}
public void CreateModelsTest()
{
using (var schemaReader = SchemaReaderProvider.GetReader(DbServerType.MsSql))
{
Tables tables = schemaReader.ReadSchema(_connectionString);
Assert.NotNull(schemaReader);
Assert.NotNull(tables);
var fileFullPathList = new List <string>();
foreach (var table in tables)
{
var model = new ModelTemplate();
model.Namespace = Namespace;
model.IncludeRelationships = true;
model.Table = table;
model.Tables = tables;
// get page content
string pageContent = model.TransformText();
// your generated model files go here
string modelsPath = Namespace;
if (!Directory.Exists(modelsPath))
{
Directory.CreateDirectory(modelsPath);
}
// Write model to file
string fileFullPath = string.Format("{0}\\{1}", modelsPath, table.ClassName) + ".cs";
File.WriteAllText(fileFullPath, pageContent);
fileFullPathList.Add(fileFullPath);
}
// Check if files exits
Assert.Equal(tables.Count, fileFullPathList.Count);
foreach (var fileFullpath in fileFullPathList)
{
Assert.True(File.Exists(fileFullpath));
}
}
}
public void It_should_throw_if_template_has_different_arguments_than_expected(string parameters)
{
var modelParams = parameters.Split(',');
var templateName = "temp1";
var template = new ModelTemplate {
TemplateName = templateName, TemplateParameters = new[] { "t1", "t2" }
};
var model = new Model {
UseTemplate = new YamlTemplateReference {
Name = templateName, Arguments = modelParams.ToDictionary(p => p)
}
};
var ex = Assert.Throws <InvalidOperationException>(() => model.ApplyTemplate(template));
Assert.That(ex.Message, Is.EqualTo($"Invalid template parameters used for template { template.TemplateName}, expected: { string.Join(", ", template.TemplateParameters)}, got: { string.Join(", ", model.UseTemplate.Arguments.Select(kv => kv.Key))}"));
}
public void It_should_throw_if_template_uses_different_parameters_than_specified()
{
var templateName = "temp1";
var template = new ModelTemplate {
TemplateName = templateName, TemplateParameters = new[] { "p1" }, Value = "${p2}"
};
var model = new Model {
UseTemplate = new YamlTemplateReference {
Name = templateName, Arguments = new Dictionary <string, string> {
{ "p1", "v1" }
}
}
};
var ex = Assert.Throws <InvalidOperationException>(() => model.ApplyTemplate(template));
Assert.That(ex.Message, Is.EqualTo("Unable to apply template temp1: Parameter ${p2} is not specified in template"));
}
public void It_should_apply_parameters_to_all_string_values()
{
var template = new ModelTemplate
{
TemplateName = "template",
TemplateParameters = new[] { "p1", "p2" },
Value = "${p1}${p2}something\\${p1}\\\\${p2}",
Values = new[] { "\\\\${p1}", "\\\\\\${p2}", "${p1} and ${p2}" },
DateTime = new DateTime(2016, 07, 04),
Number = 5,
Dictionary = new Dictionary <string, Model[]>
{
{ "${p1}", new[] { new Model {
Value = "${p1}"
}, new Model {
Value = "${p2}"
} } },
{ "${p2}", new Model[0] }
}
};
var model = new Model
{
UseTemplate = new YamlTemplateReference
{
Name = "template",
Arguments = new Dictionary <string, string> {
{ "p1", "val1" }, { "p2", "val2" }
}
}
};
model.ApplyTemplate(template);
Assert.That(model.Value, Is.EqualTo("val1val2something${p1}\\val2"));
Assert.That(model.Values, Is.EqualTo(new[] { "\\val1", "\\${p2}", "val1 and val2" }));
Assert.That(model.DateTime, Is.EqualTo(new DateTime(2016, 07, 04)));
Assert.That(model.Number, Is.EqualTo(0));
Assert.That(model.Dictionary.Keys.ToArray(), Is.EquivalentTo(new[] { "val1", "val2" }));
Assert.That(model.Dictionary["val1"][0].Value, Is.EqualTo("val1"));
Assert.That(model.Dictionary["val1"][1].Value, Is.EqualTo("val2"));
Assert.That(model.Dictionary["val2"], Is.Empty);
}
static void Main(string[] args)
{
using (var schemaReader = SchemaReaderProvider.GetReader(DbServerType.MySql))
{
var connectionString = ConfigurationManager.ConnectionStrings["MySqlSugarCrmConnectionString"].ConnectionString;
if (schemaReader == null || string.IsNullOrEmpty(connectionString))
{
// return new GeneratePocoResponse();
}
var tables = schemaReader.ReadSchema(connectionString);
if (tables == null || tables.Count <= 0)
{
throw new Exception(string.Format("Empty database or invalid connection string: {0}", connectionString));
}
var fileNames = new List <string>();
foreach (var table in tables)
{
var model = new ModelTemplate();
model.Namespace = "Sugar.PocoGen.Console.Models";
model.IncludeRelationships = true;
model.Table = table;
model.Tables = tables;
// get page content
string pageContent = model.TransformText();
string folder = "Models";
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
// Write model to file
string fileName = table.ClassName + ".cs";
File.WriteAllText(Path.Combine(folder, fileName), pageContent);
fileNames.Add(fileName);
}
}
}
public static void GenerateModel(GeneratorParameters.GeneratorParameters generatorParameters)
{
ModelTemplate template = new ModelTemplate
{
//Create our session.
Session = new Dictionary <string, object>()
};
template.Session["ClassName"] = generatorParameters.Model.Name;
template.Session["Namespace"] = generatorParameters.NamespaceName;
template.Session["Extends"] = generatorParameters.Model.Extends;
template.Session["BaseNamespace"] = generatorParameters.Model.BaseNamespace;
template.Session["Fields"] = generatorParameters.Model.Fields;
template.Initialize();
string classDef = template.TransformText();
File.WriteAllText($"{generatorParameters.OutputDir}/{generatorParameters.Model.Name}.cs", classDef);
}
/// <summary>
/// 生成 Model文件
/// </summary>
/// <param name="ns"></param>
/// <param name="author"></param>
/// <param name="outputPath"></param>
/// <param name="tablePrefix"></param>
/// <param name="connStr"></param>
public static void GenerateModel(string ns, string author, string outputPath, string tablePrefix, string connStr, ListBox.ObjectCollection items)
{
string modelOutputPath = "";
if (outputPath.LastIndexOf("\\") == 0)
{
//如果生成路径的最后一位是“\”，是在该路径下的 Model 文件夹下面建立 Model 文件
modelOutputPath = outputPath + "Model\\";
}
else //没有反斜杠，则要补上
{
modelOutputPath = outputPath + "\\Model\\";
}
//检查 Model 文件夹是否存在，不存在则创建
if (!Directory.Exists(modelOutputPath))
{
Directory.CreateDirectory(modelOutputPath);
}
string className = "";
//遍历要生成的表，生成 Model
foreach (string tableName in items)
{
//去掉表名前缀
className = tableName.Replace(tablePrefix, "");
//将类名第一个字母大写
className = className.Substring(0, 1).ToUpper() + className.Substring(1);
//定义文件路径
string filePath = modelOutputPath + className + ".cs";
//声明文档流对象，采取覆盖模式
StreamWriter sw = new StreamWriter(filePath, false);
//生成文档
sw.Write(ModelTemplate.GetModelTemplate(ns, tableName, author, className, connStr));
//关闭文档流
sw.Flush();
sw.Close();
sw.Dispose();
}
}
public Model(ModelTemplate template)
{
Template = template;
// Load geometries
if (template.Skeleton != null)
// Produce a visual tree if skeleton is defined
Children.Add(LoadNode(template.Skeleton.Root));
else
// Else, just load all geometries into the master model
LoadGeometries();
// Load equipments
foreach (EquipmentTemplate et in template.Equipments)
Equip(new Equipment(et));
// Add UIs and execute scripts within block
foreach (var item in template.UITemplates.Values)
{
// TODO: Remove ugly ref
item.CreateVisual3D(this);
}
// TODO: Alternate access to UI
}
/// <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>
/// 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 C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
// Service client
var serviceClientTemplate = new ServiceClientTemplate
{
Model = new ServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientTemplate, serviceClient.Name + ".cs");
// Service client extensions
var extensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, null),
};
await Write(extensionsTemplate, serviceClient.Name + "Extensions.cs");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate
{
Model = new ServiceClientTemplateModel(serviceClient),
};
await Write(serviceClientInterfaceTemplate, "I" + serviceClient.Name + ".cs");
// Operations
foreach (var group in serviceClient.MethodGroups)
{
// Operation
var operationsTemplate = new MethodGroupTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsTemplate, operationsTemplate.Model.MethodGroupType + ".cs");
// Service client extensions
var operationExtensionsTemplate = new ExtensionsTemplate
{
Model = new ExtensionsTemplateModel(serviceClient, group),
};
await Write(operationExtensionsTemplate, group + "Extensions.cs");
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate
{
Model = new MethodGroupTemplateModel(serviceClient, group),
};
await Write(operationsInterfaceTemplate, "I" + operationsInterfaceTemplate.Model.MethodGroupType + ".cs");
}
// Models
foreach (var model in serviceClient.ModelTypes)
{
var modelTemplate = new ModelTemplate
{
Model = new ModelTemplateModel(model),
};
await Write(modelTemplate, "Models\\" + model.Name + ".cs");
}
// Enums
foreach (var enumType in serviceClient.EnumTypes)
{
var enumTemplate = new EnumTemplate
{
Model = new EnumTemplateModel(enumType),
};
await Write(enumTemplate, "Models\\" + enumTemplate.Model.TypeDefinitionName + ".cs");
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="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>
/// 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 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"));
}
}
/// <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>
/// Generate Azure NodeJS client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
var serviceClientTemplateModel = new AzureServiceClientTemplateModel(serviceClient);
// Service client
var serviceClientTemplate = new Microsoft.Rest.Generator.Azure.NodeJS.Templates.AzureServiceClientTemplate
{
Model = serviceClientTemplateModel
};
await Write(serviceClientTemplate, serviceClient.Name.ToCamelCase() + ".js");
if (!DisableTypeScriptGeneration)
{
var serviceClientTemplateTS = new AzureServiceClientTemplateTS
{
Model = serviceClientTemplateModel,
};
await Write(serviceClientTemplateTS, serviceClient.Name.ToCamelCase() + ".d.ts");
}
//Models
if (serviceClient.ModelTypes.Any())
{
// Paged Models
foreach (var pageModel in pageModels)
{
//Add the PageTemplateModel to AzureServiceClientTemplateModel
if (!serviceClientTemplateModel.PageTemplateModels.Contains(pageModel))
{
serviceClientTemplateModel.PageTemplateModels.Add(pageModel);
}
var pageTemplate = new PageModelTemplate
{
Model = pageModel
};
await Write(pageTemplate, Path.Combine("models", pageModel.Name.ToCamelCase() + ".js"));
}
var modelIndexTemplate = new AzureModelIndexTemplate
{
Model = serviceClientTemplateModel
};
await Write(modelIndexTemplate, Path.Combine("models", "index.js"));
if (!DisableTypeScriptGeneration)
{
var modelIndexTemplateTS = new AzureModelIndexTemplateTS
{
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 AzureMethodGroupTemplate
{
Model = methodGroupModel as AzureMethodGroupTemplateModel
};
await Write(methodGroupTemplate, Path.Combine("operations", methodGroupModel.MethodGroupType.ToCamelCase() + ".js"));
}
}
}
/// <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="cm"></param>
/// <returns></returns>
public override async Task Generate(CodeModel cm)
{
var codeModel = cm as CodeModelCsa;
if (codeModel == null)
{
throw new InvalidCastException("CodeModel is not a Azure c# CodeModel");
}
// Service client
var serviceClientTemplate = new AzureServiceClientTemplate { Model = codeModel };
await Write(serviceClientTemplate, $"{codeModel.Name}{ImplementationFileExtension}");
// Service client interface
var serviceClientInterfaceTemplate = new ServiceClientInterfaceTemplate { Model = codeModel };
await Write(serviceClientInterfaceTemplate, "I" + codeModel.Name + ImplementationFileExtension);
// Operations
foreach (MethodGroupCs group in codeModel.Operations)
{
if (!group.IsCodeModelMethodGroup)
{
// Operation
var operationsTemplate = new AzureMethodGroupTemplate { Model = group };
await Write(operationsTemplate, operationsTemplate.Model.TypeName + ImplementationFileExtension);
// Operation interface
var operationsInterfaceTemplate = new MethodGroupInterfaceTemplate { Model = group };
await Write(operationsInterfaceTemplate,
$"I{operationsInterfaceTemplate.Model.TypeName}{ImplementationFileExtension}");
}
var operationExtensionsTemplate = new ExtensionsTemplate { Model = group };
await Write(operationExtensionsTemplate,
$"{group.ExtensionTypeName}Extensions{ImplementationFileExtension}");
}
// Models
foreach (CompositeTypeCs model in codeModel.ModelTypes.Concat(codeModel.HeaderTypes))
{
if (model.Extensions.ContainsKey(AzureExtensions.ExternalExtension) &&
(bool)model.Extensions[AzureExtensions.ExternalExtension])
{
continue;
}
if (model.IsResource())
{
continue;
}
var modelTemplate = new ModelTemplate { Model = model };
await Write(modelTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{model.Name}{ImplementationFileExtension}"));
}
// Enums
foreach (EnumTypeCs enumType in codeModel.EnumTypes)
{
var enumTemplate = new EnumTemplate { Model = enumType };
await Write(enumTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{enumTemplate.Model.Name}{ImplementationFileExtension}"));
}
// Page class
foreach (var pageClass in codeModel.pageClasses)
{
var pageTemplate = new PageTemplate
{
Model = new Page(pageClass.Value, pageClass.Key.Key, pageClass.Key.Value)
};
await Write(pageTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{pageTemplate.Model.TypeDefinitionName}{ImplementationFileExtension}"));
}
// Exceptions
foreach (CompositeTypeCs exceptionType in codeModel.ErrorTypes)
{
if (exceptionType.Name == "CloudError")
{
continue;
}
var exceptionTemplate = new ExceptionTemplate { Model = exceptionType };
await Write(exceptionTemplate, Path.Combine(Settings.Instance.ModelsName,
$"{exceptionTemplate.Model.ExceptionTypeDefinitionName}{ImplementationFileExtension}"));
}
}
/// <summary>
/// Generates C# code for service client.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
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 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>
/// 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>
/// 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(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),
};
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"));
}
}
/// <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="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 Azure NodeJS client code for given ServiceClient.
/// </summary>
/// <param name="serviceClient"></param>
/// <returns></returns>
public override async Task Generate(ServiceClient serviceClient)
{
var serviceClientTemplateModel = new AzureServiceClientTemplateModel(serviceClient);
// Service client
var serviceClientTemplate = new Microsoft.Rest.Generator.Azure.NodeJS.Templates.AzureServiceClientTemplate
{
Model = serviceClientTemplateModel
};
await Write(serviceClientTemplate, serviceClient.Name.ToCamelCase() + ".js");
//Models
if (serviceClient.ModelTypes.Any())
{
var modelIndexTemplate = new AzureModelIndexTemplate
{
Model = serviceClientTemplateModel
};
await Write(modelIndexTemplate, "models\\index.js");
foreach (var modelType in serviceClientTemplateModel.ModelTemplateModels)
{
var modelTemplate = new ModelTemplate
{
Model = modelType
};
await Write(modelTemplate, "models\\" + modelType.Name.ToCamelCase() + ".js");
}
}
//MethodGroups
if (serviceClientTemplateModel.MethodGroupModels.Any())
{
var methodGroupIndexTemplate = new MethodGroupIndexTemplate
{
Model = serviceClientTemplateModel
};
await Write(methodGroupIndexTemplate, "operations\\index.js");
foreach (var methodGroupModel in serviceClientTemplateModel.MethodGroupModels)
{
var methodGroupTemplate = new AzureMethodGroupTemplate
{
Model = methodGroupModel as AzureMethodGroupTemplateModel
};
await Write(methodGroupTemplate, "operations\\" + methodGroupModel.MethodGroupType.ToCamelCase() + ".js");
}
}
}
