/// <summary>
///
/// </summary>
/// <param name="m"></param>
/// <returns></returns>
private Task Generate(GenerateHtml m)
{
return(Task.Run(() =>
{
try
{
var model = HttpService.GetRequestByUrl(m.GenerateHtmlUrl);
if (!model.IsSuccessful)
{
m.IsSuccess = false;
return;
}
var path = m.GenerateHtmlPath;
var dir = System.IO.Path.GetDirectoryName(path);
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir ?? throw new InvalidOperationException());
}
File.WriteAllText(path, model.Content, Encoding.UTF8);
m.IsSuccess = File.Exists(path);
}
catch (Exception ex)
{
Write($"[{DateTime.Now:mm:ss}] Url:{m.GenerateHtmlUrl}；{ex.Message}");
LogHelper.Fatal(ex.Message, ex);
}
}));
}
/// <summary>
/// 获取记录
/// </summary>
/// <returns></returns>
public virtual GenerateHtml GetGenerateHtml()
{
return(Db(db =>
{
var list = db.GetList <GenerateHtml>().ToList();
//1条
if (list.Count == 1)
{
return list.First();
}
//0条
if (list.Count == 0)
{
var model = new GenerateHtml();
db.Insert <Guid, GenerateHtml>(model);
return model;
}
//多条
var m = list.First();
var rows = list.Where(p => p != m);
foreach (var row in rows)
{
db.Delete(row);
}
return m;
}));
}
private static void GenerateMethods(IEnumerable <MethodDom> methods, OfflineDynamicPage parentNode, string typeUrl)
{
var groups = methods.GroupBy(_ => _.SimpleName).OrderBy(_ => _.Key);
foreach (var member in groups)
{
string url = typeUrl + "/" + member.Key;
string html = member.Count() == 1
? GenerateHtml.Generate(member.Single())
: GenerateHtml.Generate(member);
var memberItem = new OfflineDynamicPage
{
Parent = parentNode,
UrlPart = url,
RussianTitle = member.Key,
RussianContent = html,
};
if (1 < member.Count())
{
GenerateOverloadMethods(member, memberItem, url);
}
parentNode.Childs.Add(memberItem);
}
}
public void ForOrderTest()
{
// create html using template and a model
var html = GenerateHtml.ForOrder();
Assert.IsNotNull(html);
// output
Console.WriteLine(html);
}
private static void AddAssembly(OfflineDynamicPage rootItems, AssemblyDom asmDom)
{
var asmItem = new OfflineDynamicPage
{
Parent = rootItems,
UrlPart = asmDom.Name,
RussianTitle = asmDom.Name,
RussianContent = GenerateHtml.Generate(asmDom),
};
rootItems.Childs.Add(asmItem);
AddNamespaces(asmItem, asmDom.Namespaces);
}
private static void GenerateOverloadMethods(IEnumerable <MethodDom> methods, OfflineDynamicPage parentNode, string baseUrl)
{
foreach (var m in methods.OrderBy(_ => _.ShortSignature))
{
var item = new OfflineDynamicPage
{
Parent = parentNode,
UrlPart = baseUrl + "/" + m.OverloadIndex.ToString(),
RussianTitle = m.ShortSignature,
RussianContent = GenerateHtml.Generate(m),
};
parentNode.Childs.Add(item);
}
}
private static void AddNamespaces(OfflineDynamicPage parentNode, IEnumerable <NamespaceDom> namespaces)
{
foreach (var namesp in namespaces)
{
var namespaceItem = new OfflineDynamicPage
{
Parent = parentNode,
UrlPart = GenerateHtml.Navigation.UrlPrefix + namesp.Name.Replace('.', '/'),
RussianTitle = namesp.Name,
RussianContent = GenerateHtml.Generate(namesp)
};
AddTypes(namespaceItem, namesp.Types);
parentNode.Childs.Add(namespaceItem);
}
}
public static XElement GetParametersLongSignature(ParameterInfo[] pars, int skipCount = 0)
{
if (pars.Length < 1 + skipCount)
{
return(new XElement("span"));
}
var args = pars
.Skip(skipCount)
.SelectMany(p => new[]
{
GenerateHtml.BuildTypeUrl(p.ParameterType, false),
new XElement("span", ","),
})
.ToArray();
return(new XElement("span", new XElement("span", "("), args.Take(args.Count() - 1), new XElement("span", ")")));
}
private static void AddTypes(OfflineDynamicPage parentNode, IEnumerable <TypeDom> types)
{
if (types == null || !types.Any())
{
return;
}
foreach (var type in types)
{
var typeItem = new OfflineDynamicPage
{
Parent = parentNode,
UrlPart = GenerateHtml.Navigation.UrlPrefix + type.Namespace.Replace('.', '/') + "/" + type.SimpleName,
RussianTitle = type.GetDisplayName(false),
RussianContent = GenerateHtml.Generate(type),
};
if (type.NestedTypes != null && type.NestedTypes.Length > 0)
{
var nestedTypeItem = new OfflineDynamicPage
{
Parent = typeItem,
UrlPart = typeItem.UrlPart + "/NestedTypes",
RussianTitle = GenerateHtml.NestedTypesName,
RussianContent = GenerateHtml.Generate(
new TypePartialData {
SectionType = MemberTypeSection.NestedTypes, Type = type
}
),
};
AddTypes(nestedTypeItem, type.NestedTypes);
typeItem.Childs.Add(nestedTypeItem);
}
AddMembers(typeItem, type, type.Constructors, MemberTypeSection.Constructors);
AddMembers(typeItem, type, type.Properties, MemberTypeSection.Properties);
AddMembers(typeItem, type, type.Methods, MemberTypeSection.Methods);
AddMembers(typeItem, type, type.ExtentionMethods, MemberTypeSection.ExtentionMethods);
AddMembers(typeItem, type, type.Operators, MemberTypeSection.Operators);
AddMembers(typeItem, type, type.Fields, MemberTypeSection.Fields);
AddMembers(typeItem, type, type.Events, MemberTypeSection.Events);
parentNode.Childs.Add(typeItem);
}
}
private bool GenerateOutputFile()
{
string templateFile = Program.Config.GetTemplateFilePath();
if (templateFile == null)
{
lastOutputGenError = Lang.Get["LoadProjectErrorNoTemplate"];
return(false);
}
outputFile = Program.Config.GetOutputFilePath();
TemplateList templateList;
try{
templateList = new TemplateReader(templateFile).ReadTemplates();
}catch (TemplateException e) {
lastOutputGenError = e.Message;
return(false);
}
GenerateHtml generator = new GenerateHtml(templateList, variables);
switch (generator.ToFile(outputFile))
{
case GenerateHtml.Result.Succeeded:
return(true);
case GenerateHtml.Result.TemplateError:
lastOutputGenError = Lang.Get["LoadProjectErrorInvalidTemplate", generator.LastError];
return(false);
case GenerateHtml.Result.IoError:
lastOutputGenError = Lang.Get["LoadProjectErrorIO", generator.LastError];
return(false);
default:
lastOutputGenError = Lang.Get["LoadProjectErrorUnknown"];
return(false);
}
}
private static void AddMembers(OfflineDynamicPage parentNode, TypeDom type, MemberDom[] members, MemberTypeSection section)
{
if (members == null || members.Length == 0)
{
return;
}
var sectionItem = new OfflineDynamicPage
{
Parent = parentNode,
UrlPart = parentNode.UrlPart + "/" + section.ToString(),
RussianTitle = GenerateHtml.GetSectionName(section),
RussianContent = GenerateHtml.Generate(new TypePartialData {
SectionType = section, Type = type
}),
};
if (section == MemberTypeSection.Methods || section == MemberTypeSection.ExtentionMethods)
{
GenerateMethods((MethodDom[])members, sectionItem, parentNode.UrlPart);
}
else
{
foreach (var member in members)
{
//ToDo: Группировка переопределенных методов.
var memberItem = new OfflineDynamicPage
{
Parent = sectionItem,
UrlPart = parentNode.UrlPart + "/" + member.SimpleName,
RussianTitle = member.ShortSignature,
RussianContent = GenerateHtml.Generate(member),
};
sectionItem.Childs.Add(memberItem);
}
}
parentNode.Childs.Add(sectionItem);
}
public static OfflineDynamicPage BuildSolution(SolutionDom solutionDom, bool onlyNamespaces = true)
{
var ret = new OfflineDynamicPage
{
RussianTitle = solutionDom.Name,
RussianContent = GenerateHtml.Generate(solutionDom),
};
if (onlyNamespaces)
{
AddNamespaces(ret, solutionDom.Namespaces);
}
else
{
foreach (var asm in solutionDom.Assemblies)
{
AddAssembly(ret, asm);
}
}
return(ret);
}
private void btnHtml_Click(object sender, EventArgs e)
{
GenerateHtml html = new GenerateHtml();
string name = cboTable.SelectedItem.ToString();
html.Name = name;
//此处的url截取最后一个/后面的字符串,因为mvc路由设置了Area
int lastIndex = txtUrl.Text.LastIndexOf('/');
if (lastIndex > 0)
{
html.Url = txtUrl.Text.Trim();
html.QueryAndDownloadUrl = txtUrl.Text.Substring(lastIndex + 1);
}
else
{
html.Url = txtUrl.Text.Trim();
}
rtbIndex.Text = html.Index();
rtbQueryForm.Text = html.QueryForm();
txtAddForm.Text = html.AddForm();
txtUpdateForm.Text = html.UpdateForm();
}
/// <summary>
/// 更新
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual bool UpdateGenerateHtml(GenerateHtml model)
{
return(Da.Update(model));
}
