/// <summary>
/// 插入或更新文件夹
/// </summary>
internal static async ValueTask UpsertFolderAsync(ModelFolder folder, Transaction txn)
{
if (folder.Parent != null)
{
throw new InvalidOperationException("Can't save none root folder.");
}
//TODO:check need add version
IntPtr keyPtr;
IntPtr dataPtr = SerializeModel(folder, out _);
unsafe
{
byte *pk = stackalloc byte[KeyUtil.FOLDER_KEY_SIZE];
KeyUtil.WriteFolderKey(pk, folder.AppId, folder.TargetModelType);
keyPtr = new IntPtr(pk);
}
var req = new ClrInsertRequire
{
RaftGroupId = KeyUtil.META_RAFTGROUP_ID,
KeyPtr = keyPtr,
KeySize = new IntPtr(KeyUtil.FOLDER_KEY_SIZE),
DataPtr = dataPtr,
SchemaVersion = 0,
OverrideIfExists = true,
DataCF = -1
};
IntPtr reqPtr;
unsafe { reqPtr = new IntPtr(&req); }
await HostApi.ExecKVInsertAsync(txn.Handle, reqPtr);
}
/// <summary>
/// 根据当前选择的节点查找新建文件夹节点的上级节点
/// </summary>
public DesignNode FindNewFolderParentNode(DesignNode selected, out uint appID, out ModelType modelType)
{
appID = 0;
modelType = ModelType.Application;
if (selected == null)
{
return(null);
}
if (selected is ModelRootNode rootNode)
{
appID = rootNode.AppID;
modelType = rootNode.TargetType;
return(selected);
}
if (selected.NodeType == DesignNodeType.FolderNode)
{
ModelFolder folder = ((FolderNode)selected).Folder;
appID = folder.AppId;
modelType = folder.TargetModelType;
return(selected);
}
return(null);
}
public void Load(System.IO.Stream stream)
{
CanSave = true;
Read(new FileReader(stream));
TreeNode node = new QuickAccessFolder(this, "Quick access");
Nodes.Add(node);
Dictionary <string, TreeNode> folders = new Dictionary <string, TreeNode>();
foreach (var file in files)
{
string ext = Utils.GetExtension(file.FileName);
string folderName = "Other";
if (CategoryLookup.ContainsKey(ext))
{
folderName = CategoryLookup[ext];
}
if (!folders.ContainsKey(folderName))
{
TreeNode folder = new QuickAccessFileFolder(folderName);
if (folderName == "Textures")
{
folder = new TextureFolder(this, "Textures");
}
if (folderName == "Models")
{
folder = new ModelFolder("Models");
}
if (folderName == "Animations")
{
folder = new AnimationFolder("Animations");
}
node.Nodes.Add(folder);
folders.Add(folderName, folder);
}
string name = Path.GetFileName(file.FileName).Split('[').FirstOrDefault();
string imageKey = "fileBlank";
switch (ext)
{
case ".bntx": imageKey = "bntx"; break;
case ".gfbmdl": imageKey = "model"; break;
}
TreeNode fodlerNode = folders[folderName];
fodlerNode.Nodes.Add(new QuickAccessFile(name)
{
Tag = file,
ImageKey = imageKey,
SelectedImageKey = imageKey,
});
}
}
public static dynamic GetTSObject(ModelFolder dynObject)
{
if (dynObject is null)
{
return(null);
}
return(dynObject.teklaObject);
}
internal Task SaveAsync()
{
//查找文件夹直至根级文件夹，然后序列化保存根级文件夹
ModelFolder rootFolder = Folder.GetRoot();
//保存节点模型
return(StagedService.SaveFolderAsync(rootFolder));
}
private void addFolder(object sender, System.EventArgs e)
{
ModelFolder folder;
folder = new ModelFolder("New Folder");
model.Folders.Add(folder);
refreshTree();
}
/// <summary>
/// 检查指定目录是否原本是根目录
/// </summary>
internal static bool CheckRootFolderCacheExists(ModelFolder folder)
{
throw ExceptionHelper.NotImplemented();
// string path = PathService.GetFolderPath(folder, false);
// ModelFolder current = FileCacheService.LoadFromCache(path) as ModelFolder;
// if (current == null || current.PersistentState != PersistentState.Deleted)
// return false;
// return true;
}
/// <summary>
/// 保存模型类型的根目录
/// </summary>
internal static Task SaveFolderAsync(ModelFolder folder)
{
if (folder.Parent != null)
{
throw new InvalidOperationException("仅允许保存模型类型的根目录");
}
var data = BinSerializer.Serialize(folder, false, null);
return(SaveAsync(StagedType.Folder, $"{folder.AppId}-{(byte)folder.TargetModelType}" /*不要使用folder.Id*/, data));
}
/// <summary>
/// 删除根文件夹
/// </summary>
internal static async ValueTask DeleteFolderAsync(ModelFolder folder, DbTransaction txn)
{
if (folder.Parent != null)
{
throw new InvalidOperationException("Can't delete none root folder.");
}
var id = $"{folder.AppId.ToString()}.{(byte)folder.TargetModelType}"; //RootFolder.Id=Guid.Empty
using var cmd = SqlStore.Default.MakeCommand();
cmd.Connection = txn.Connection;
cmd.Transaction = txn;
BuildDeleteMetaCommand(cmd, Meta_Folder, id);
await cmd.ExecuteNonQueryAsync();
}
private void ModelFolder_DragDrop(object sender, DragEventArgs e)
{
string[] files = (string[])e.Data.GetData(DataFormats.FileDrop);
foreach (string file in files)
{
if (ModelFolder.Text.Length == 0)
{
ModelFolder.Text = file;
}
else
{
ModelFolder.AppendText("\r\n" + file);
}
Console.WriteLine(file);
}
}
/// <summary>
/// 用于设计时加载所有Folder
/// </summary>
internal static async ValueTask <ModelFolder[]> LoadAllFolderAsync()
{
byte key = KeyUtil.METACF_FOLDER_PREFIX;
IntPtr keyPtr;
unsafe { keyPtr = new IntPtr(&key); }
var req = new ClrScanRequire
{
RaftGroupId = KeyUtil.META_RAFTGROUP_ID,
BeginKeyPtr = keyPtr,
BeginKeySize = new IntPtr(1),
EndKeyPtr = IntPtr.Zero,
EndKeySize = IntPtr.Zero,
FilterPtr = IntPtr.Zero,
Skip = 0,
Take = uint.MaxValue,
DataCF = -1
};
IntPtr reqPtr;
unsafe { reqPtr = new IntPtr(&req); }
var res = await HostApi.ReadIndexByScanAsync(reqPtr);
var folders = new ModelFolder[res.Length];
try
{
int index = 0;
res.ForEachRow((kp, ks, vp, vs) =>
{
folders[index] = (ModelFolder)DeserializeModel(vp, vs);
index++;
});
}
catch (Exception) { throw; }
finally { res.Dispose(); }
return(folders);
}
private static void LoopAddFolder(Dictionary <Guid, PermissionNode> dic, PermissionNode parent, ModelFolder folder)
{
var parentNode = parent;
if (folder.Parent != null)
{
var node = new PermissionNode(folder.Name);
dic.Add(folder.Id, node);
parent.Childs.Add(node);
parentNode = node;
}
if (folder.HasChilds)
{
for (int i = 0; i < folder.Childs.Count; i++)
{
LoopAddFolder(dic, parentNode, folder.Childs[i]);
}
}
}
/// <summary>
/// Return recognition results.
/// </summary>
/// <param name="dc">Context object containing information for a single turn of conversation with a user.</param>
/// <param name="activity">The incoming activity received from the user. The Text property value is used as the query text for QnA Maker.</param>
/// <param name="cancellationToken">A cancellation token that can be used by other objects or threads to receive notice of cancellation.</param>
/// <param name="telemetryProperties">Additional properties to be logged to telemetry with the LuisResult event.</param>
/// <param name="telemetryMetrics">Additional metrics to be logged to telemetry with the LuisResult event.</param>
/// <returns>A <see cref="RecognizerResult"/> containing the QnA Maker result.</returns>
public override async Task <RecognizerResult> RecognizeAsync(DialogContext dc, Schema.Activity activity, CancellationToken cancellationToken, Dictionary <string, string> telemetryProperties = null, Dictionary <string, double> telemetryMetrics = null)
{
var text = activity.Text ?? string.Empty;
var detectAmbiguity = DetectAmbiguousIntents.GetValue(dc.State);
_modelFolder = ModelFolder.GetValue(dc.State);
_snapshotFile = SnapshotFile.GetValue(dc.State);
InitializeModel();
var recognizerResult = new RecognizerResult()
{
Text = text,
Intents = new Dictionary <string, IntentScore>(),
};
if (string.IsNullOrWhiteSpace(text))
{
// nothing to recognize, return empty recognizerResult
return(recognizerResult);
}
if (ExternalEntityRecognizer != null)
{
// Run external recognition
var externalResults = await ExternalEntityRecognizer.RecognizeAsync(dc, activity, cancellationToken, telemetryProperties, telemetryMetrics).ConfigureAwait(false);
recognizerResult.Entities = externalResults.Entities;
}
// Score with orchestrator
var results = _resolver.Score(text);
// Add full recognition result as a 'result' property
recognizerResult.Properties.Add(ResultProperty, results);
if (results.Any())
{
var topScore = results[0].Score;
// if top scoring intent is less than threshold, return None
if (topScore < UnknownIntentFilterScore)
{
recognizerResult.Intents.Add(NoneIntent, new IntentScore()
{
Score = 1.0
});
}
else
{
// add top score
recognizerResult.Intents.Add(results[0].Label.Name, new IntentScore()
{
Score = results[0].Score
});
// Disambiguate if configured
if (detectAmbiguity)
{
var thresholdScore = DisambiguationScoreThreshold.GetValue(dc.State);
var classifyingScore = Math.Round(topScore, 2) - Math.Round(thresholdScore, 2);
var ambiguousResults = results.Where(item => item.Score >= classifyingScore).ToList();
if (ambiguousResults.Count > 1)
{
// create a RecognizerResult for each ambiguous result.
var recognizerResults = ambiguousResults.Select(result => new RecognizerResult()
{
Text = text,
AlteredText = result.ClosestText,
Entities = recognizerResult.Entities,
Properties = recognizerResult.Properties,
Intents = new Dictionary <string, IntentScore>()
{
{ result.Label.Name, new IntentScore()
{
Score = result.Score
} }
},
});
// replace RecognizerResult with ChooseIntent => Ambiguous recognizerResults as candidates.
recognizerResult = CreateChooseIntentResult(recognizerResults.ToDictionary(result => Guid.NewGuid().ToString(), result => result));
}
}
}
}
else
{
// Return 'None' if no intent matched.
recognizerResult.Intents.Add(NoneIntent, new IntentScore()
{
Score = 1.0
});
}
await dc.Context.TraceActivityAsync($"{nameof(OrchestratorAdaptiveRecognizer)}Result", JObject.FromObject(recognizerResult), nameof(OrchestratorAdaptiveRecognizer), "Orchestrator Recognition", cancellationToken).ConfigureAwait(false);
TrackRecognizerResult(dc, $"{nameof(OrchestratorAdaptiveRecognizer)}Result", FillRecognizerResultTelemetryProperties(recognizerResult, telemetryProperties, dc), telemetryMetrics);
return(recognizerResult);
}
public async Task <object> Handle(DesignHub hub, InvokeArgs args)
{
//读取参数
int selectedNodeType = args.GetInt32();
string selectedNodeId = args.GetString();
string name = args.GetString();
if (string.IsNullOrEmpty(name))
{
throw new Exception("名称不能为空");
}
//获取选择的节点
var selectedNode = hub.DesignTree.FindNode((DesignNodeType)selectedNodeType, selectedNodeId);
if (selectedNode == null)
{
throw new Exception("无法找到当前节点");
}
//根据选择的节点获取合适的插入位置
var parentNode = hub.DesignTree.FindNewFolderParentNode(selectedNode, out uint appId, out ModelType modelType);
if (parentNode == null)
{
throw new Exception("无法找到上级节点");
}
if (parentNode.Nodes.Exists(t => t.NodeType == DesignNodeType.FolderNode && t.Text == name))
{
throw new Exception("当前目录下已存在同名文件夹");
}
//判断当前模型根节点有没有签出
var rootNode = hub.DesignTree.FindModelRootNode(appId, modelType);
bool rootNodeHasCheckout = rootNode.IsCheckoutByMe;
if (!await rootNode.Checkout())
{
throw new Exception($"Can't checkout: {rootNode.FullName}");
}
////注意:需要重新引用上级文件夹节点，因自动签出上级节点可能已重新加载
//if (!rootNodeHasCheckout && parentNode.NodeType == DesignNodeType.FolderNode)
//{
// parentNode = rootNode.FindFolderNode(((FolderNode)parentNode).Folder.ID);
// if (parentNode == null)
// throw new Exception("上级节点已不存在，请刷新重试");
//}
// 判断选择节点即parentNode是文件夹还是模型根节点
ModelFolder model = null;
if (parentNode.NodeType == DesignNodeType.FolderNode)
{
model = new ModelFolder(((FolderNode)parentNode).Folder, name);
}
else if (parentNode.NodeType == DesignNodeType.ModelRootNode)
{
//判断是否存在根文件夹
if (rootNode.RootFolder == null)
{
rootNode.RootFolder = new ModelFolder(appId, rootNode.TargetType);
}
model = new ModelFolder(rootNode.RootFolder, name);
}
else
{
throw new Exception("不允许在此节点创建文件夹");
}
var node = new FolderNode(model);
//添加至设计树
var insertIndex = parentNode.Nodes.Add(node);
// 添加至根节点索引内
rootNode.AddFolderIndex(node);
// 保存到本地
await node.SaveAsync();
return(new NewNodeResult
{
ParentNodeType = (int)parentNode.NodeType,
ParentNodeID = parentNode.ID,
NewNode = node,
RootNodeID = rootNodeHasCheckout ? null : rootNode.ID,
InsertIndex = insertIndex
});
}
/// <summary>
/// 移除新建的根目录所保存的本地缓存
/// </summary>
internal static void RemoveRootFolderCache(ModelFolder folder)
{
throw ExceptionHelper.NotImplemented();
// string path = PathService.GetFolderPath(folder, true);
// FileCacheService.DeleteCache(path);
}
public FolderNode(ModelFolder folder)
{
Folder = folder;
Text = Folder.Name;
}
