public static async Task <Tuple <long, long> > PCHelpEnsure(
IServiceInstanceManager sim,
long?ScopeId,
IContentManager ContentManger,
IFilePathResolver FilePathResolver,
IDocumentManager DocManager,
IDocumentCategoryManager CatManager
)
{
var re = await DocManager.DocEnsureFromFiles(
CatManager,
//"pc-help",
null,
FilePathResolver.Resolve($"root://StaticResources/帮助文档/PC文档")
);
await sim.UpdateSetting <HygouSetting>(
ScopeId,
s =>
{
s.PCHelpCenterDefaultDocId = re[0].Children[0].Id;
});
var tail_doc_list = await ContentManger.ContentEnsure(
"PC页面尾部文档列表",
"PC页面尾部文档列表",
null,
re.Select(cat =>
new ContentItem {
Title1 = cat.Name,
Items = cat.Children.Select(doc =>
new ContentItem {
Title1 = doc.Name, Uri = $"/help/doc/{doc.Id}"
}
).ToArray()
}
).Take(4).ToArray()
);
var tail_link_list = await ContentManger.ContentEnsure(
"PC页面尾部链接列表",
"PC页面尾部链接列表",
null,
re.Last().Children.Select(doc =>
new ContentItem {
Title1 = doc.Name, Uri = $"/help/doc/{doc.Id}"
}
).ToArray()
);
await sim.UpdateSetting <FriendlyContentSetting>(
ScopeId,
s =>
{
s.PCHomeTailMenuId = tail_doc_list.Id;
});
return(Tuple.Create(tail_doc_list.Id, tail_link_list.Id));
}
public MacroStartFunction[] GetEntryPoints(string macroPath, string workDir)
{
var path = m_FilePathResolver.Resolve(macroPath, workDir);
//TODO: implement check for xCAD macro
return(m_App.OpenMacro(path).EntryPoints.Select(
x => new MacroStartFunction(x.ModuleName, x.ProcedureName)).ToArray());
}
public static async Task MobileHelpEnsure(
IFilePathResolver FilePathResolver,
IDocumentManager DocManager,
IDocumentCategoryManager CatManager
)
{
await DocManager.DocEnsureFromFiles(
CatManager,
null,
FilePathResolver.Resolve($"root://StaticResources/帮助文档/手机文档"),
null
);
}
public bool TryRunMacroCommand(Triggers_e trigger, CommandMacroInfo macroInfo, IXDocument targetDoc, string workDir)
{
try
{
m_Logger.Log($"Invoking '{trigger}' trigger for '{macroInfo.Title}'", LoggerMessageSeverity_e.Debug);
var eventType = GetEventType(trigger);
var eventArgs = new MacroRunningArguments(macroInfo, targetDoc)
{
Cancel = false
};
m_ToolbarModuleProxy.CallMacroRunning(eventType, eventArgs);
if (!eventArgs.Cancel)
{
var opts = eventArgs.MacroInfo.UnloadAfterRun ? MacroRunOptions_e.UnloadAfterRun : MacroRunOptions_e.Default;
var macroPath = m_FilePathResolver.Resolve(eventArgs.MacroInfo.MacroPath, workDir);
m_Logger.Log($"Running macro '{macroPath}' with arguments '{eventArgs.MacroInfo.Arguments}'", LoggerMessageSeverity_e.Debug);
var entryPoint = eventArgs.MacroInfo.EntryPoint;
if (entryPoint == null)
{
throw new UserException($"Entry point is not specified for macro '{macroInfo.Title}'");
}
m_Runner.RunMacro(m_App, macroPath,
new MacroEntryPoint(entryPoint.ModuleName, entryPoint.SubName),
opts, eventArgs.MacroInfo.Arguments, null);
return(true);
}
else
{
m_Logger.Log($"Trigger '{trigger}' for '{macroInfo.Title}' invoking cancelled", LoggerMessageSeverity_e.Debug);
return(false);
}
}
catch (Exception ex)
{
m_Logger.Log(ex);
m_MsgSvc.ShowError(ex, $"Failed to run a macro '{macroInfo.Title}' on trigger '{trigger}'");
return(false);
}
}
public override IPackageInstallResult Do(IPackage package, IFilePathResolver target){
var result = new DefaultPackageInstallResult{Message = ToString()};
package.PathResolver.ResolveAll("")
.Where(s => !(GetBehaviour(s) == CopyBehaviour.Skip))
.Select(s =>{
target.Resolve("~/" + s, false);
return s;
})
.ToList();
foreach (var file in package.PathResolver.ResolveAll("")){
var behaviour = GetBehaviour(file);
switch (behaviour){
case CopyBehaviour.Skip:
result.SubMessages.Add(string.Format("SKIP:{0}", file));
// Console.WriteLine(string.Format("SKIP:{0}", file));
break;
case CopyBehaviour.None:
goto default;
case CopyBehaviour.OverWrite:
goto default;
case CopyBehaviour.NewOnly:
if (!target.Exists(file)){
goto default;
}
result.SubMessages.Add(string.Format("EXISTS:{0}", file));
Console.WriteLine(string.Format("EXISTS:{0}", file));
break;
default:
target.Write(file, package.PathResolver.ReadBinary(file));
result.SubMessages.Add(string.Format("COPY:{0}", file));
// Console.WriteLine(string.Format("COPY:{0}", file));
break;
}
}
return result;
}
public override ValidationResult Validate(object value, CultureInfo cultureInfo)
{
try
{
if (!string.IsNullOrEmpty(value as string))
{
var filePath = (string)value;
if (Parameters != null)
{
filePath = m_FilePathResolver.Resolve(filePath, Parameters.WorkingDirectory);
}
if (!File.Exists(filePath))
{
return(new ValidationResult(false, "File does not exist"));
}
else
{
return(ValidationResult.ValidResult);
}
}
else
{
if (AllowEmptyValues)
{
return(ValidationResult.ValidResult);
}
else
{
return(new ValidationResult(false, "Path is not specified"));
}
}
}
catch (Exception ex)
{
return(new ValidationResult(false, ex.ParseUserError("Invalid path")));
}
}
internal static IXImage GetCommandIcon(this CommandItemInfo info, IIconsProvider[] iconsProviders, IFilePathResolver pathResolver, string workDir)
{
IXImage icon = null;
try
{
if (!string.IsNullOrEmpty(info.IconPath))
{
var iconPath = pathResolver.Resolve(info.IconPath, workDir);
var provider = iconsProviders.FirstOrDefault(p => p.Matches(iconPath));
if (provider != null)
{
icon = provider.GetIcon(iconPath);
}
}
}
catch
{
}
if (icon == null)
{
if (info is CommandMacroInfo)
{
icon = new ImageEx(Resources.macro_icon_default.GetBytes(),
Resources.macro_vector);
}
else if (info is CommandGroupInfo)
{
icon = new ImageEx(Resources.group_icon_default.GetBytes(),
Resources.macros_vector);
}
}
return(icon);
}
