/// <summary>
/// Searches the CustomTag collection and processes the AIML if an appropriate tag handler is found
/// </summary>
/// <param name="user">the user who originated the request</param>
/// <param name="query">the query that produced this node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="node">the node to evaluate</param>
/// <returns>the output string</returns>
public AIMLTagHandler getBespokeTags(User user, SubQuery query, Request request, Result result, XmlNode node)
{
if (CustomTags.ContainsKey(node.Name.ToLower()))
{
TagHandler customTagHandler = CustomTags[node.Name.ToLower()];
AIMLTagHandler newCustomTag = customTagHandler.Instantiate(LateBindingAssemblies);
if (object.Equals(null, newCustomTag))
{
return(null);
}
else
{
newCustomTag.user = user;
newCustomTag.query = query;
newCustomTag.request = request;
newCustomTag.result = result;
newCustomTag.templateNode = node;
newCustomTag.bot = this;
return(newCustomTag);
}
}
else
{
return(null);
}
}
/// <summary>
/// Given a request containing user input, produces a result from the bot
/// </summary>
/// <param name="request">the request from the user</param>
/// <returns>the result to be output to the user</returns>
public async Task <Result> Query(Request request)
{
return(await Task.Run(() =>
{
Result result = new Result(request.user, this, request);
if (this.isAcceptingUserInput)
{
// Normalize the input
AIMLLoader loader = new AIMLLoader(this);
LIAM.Normalize.SplitIntoSentences splitter = new LIAM.Normalize.SplitIntoSentences(this);
string[] rawSentences = splitter.Transform(request.rawInput);
foreach (string sentence in rawSentences)
{
result.InputSentences.Add(sentence);
string path = loader.generatePath(sentence, request.user.getLastBotOutput(), request.user.Topic, true);
result.NormalizedPaths.Add(path);
}
// grab the templates for the various sentences from the graphmaster
foreach (string path in result.NormalizedPaths)
{
Utils.SubQuery query = new SubQuery(path);
query.Template = this.Graphmaster.evaluate(path, query, request, MatchState.UserInput, new StringBuilder());
result.SubQueries.Add(query);
}
// process the templates into appropriate output
foreach (SubQuery query in result.SubQueries)
{
if (query.Template.Length > 0)
{
try
{
XmlNode templateNode = AIMLTagHandler.getNode(query.Template);
string outputSentence = this.processNode(templateNode, query, request, result, request.user);
if (outputSentence.Length > 0)
{
result.OutputSentences.Add(outputSentence);
}
}
catch
{
this.writeToLog("WARNING! A problem was encountered when trying to process the input: " + request.rawInput + " with the template: \"" + query.Template + "\"");
}
}
}
}
else
{
result.OutputSentences.Add(this.NotAcceptingUserInputMessage);
}
// populate the Result object
result.Duration = DateTime.Now - request.StartedOn;
request.user.addResult(result);
return result;
}));
}
/// <summary>
/// Loads any custom tag handlers found in the dll referenced in the argument
/// </summary>
/// <param name="pathToDLL">the path to the dll containing the custom tag handling code</param>
public void loadCustomTagHandlers(string pathToDLL)
{
Assembly tagDLL = Assembly.LoadFrom(pathToDLL);
Type[] tagDLLTypes = tagDLL.GetTypes();
for (int i = 0; i < tagDLLTypes.Length; i++)
{
object[] typeCustomAttributes = tagDLLTypes[i].GetCustomAttributes(false);
for (int j = 0; j < typeCustomAttributes.Length; j++)
{
if (typeCustomAttributes[j] is CustomTagAttribute)
{
// We've found a custom tag handling class
// so instantiate it and store it away in the hashtable for
// later usage
AIMLTagHandler customtaghandler = (AIMLTagHandler)tagDLL.CreateInstance(tagDLLTypes[i].FullName);
string tagname = tagDLLTypes[i].Name.ToLower();
if (this.CustomTags.ContainsKey(tagname))
{
throw new Exception("ERROR! Unable to add the custom tag: <" + tagname + ">, found in: " + pathToDLL + " as a handler for this tag already exists.");
}
else
{
this.CustomTags.Add(tagname, customtaghandler);
}
}
}
}
}
/// <summary>
/// Searches the CustomTag collection and processes the AIML if an appropriate tag handler is found
/// </summary>
/// <param name="user">the user who originated the request</param>
/// <param name="query">the query that produced this node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="node">the node to evaluate</param>
/// <returns>the output string</returns>
public AIMLTagHandler getBespokeTags(User user, SubQuery query, Request request, Result result, XmlNode node)
{
if (this.CustomTags.ContainsKey(node.Name.ToLower()))
{
TagHandler customTagHandler = (TagHandler)this.CustomTags[node.Name.ToLower()];
AIMLTagHandler newCustomTag = customTagHandler.Instantiate(this.LateBindingAssemblies);
if (object.Equals(null, newCustomTag))
{
return(null);
}
else
{
newCustomTag.user = user;
newCustomTag.query = query;
newCustomTag.request = request;
newCustomTag.result = result;
newCustomTag.templateNode = node;
newCustomTag.templateNode.Attributes.RemoveNamedItem("xmlns");
newCustomTag.InputString = node.OuterXml;
newCustomTag.bot = this;
return(newCustomTag);
}
}
else
{
return(null);
}
}
public override float CanUnify(Unifiable with)
{
if (templateNode.NodeType == XmlNodeType.Text)
{
string srch = (" " + with.ToValue(query) + " ").ToUpper();
return(((" " + templateNode.InnerText + " ").ToUpper().Contains(srch)) ? AND_TRUE : AND_FALSE);
}
if (templateNode.HasChildNodes)
{
// recursively check
foreach (XmlNode childNode in templateNode.ChildNodes)
{
try
{
if (childNode.NodeType == XmlNodeType.Text)
{
string srch = (" " + with.ToValue(query) + " ").ToUpper();
return(((" " + childNode.InnerText + " ").ToUpper().Contains(srch)) ? AND_TRUE : AND_FALSE);
}
AIMLTagHandler part = GetChildTagHandler(childNode);
if (part.CallCanUnify(with) > 0)
{
return(AND_FALSE);
}
}
catch (Exception e)
{
Proc.writeToLog(e);
writeToLogWarn("" + e);
}
}
return(AND_TRUE);
}
return(AND_TRUE);
}
private AIMLTagHandler proccessTemplate(SubQuery query, Request request, Result result,
XmlNode templateNode, Unifiable sGuard,
out bool createdOutput, out bool templateSucceeded,
AIMLTagHandler parentHandlerU, TemplateInfo templateInfo,
bool copyChild, bool copyParent)
{
ChatLabel label = request.PushScope;
var prevTraced = request.IsTraced;
var untraced = request.Graph.UnTraced;
var superTrace = templateInfo != null && templateInfo.IsTraced;
try
{
if (superTrace)
{
request.IsTraced = true;
request.Graph.UnTraced = false;
}
var th = proccessResponse000(query, request, result, templateNode, sGuard,
out createdOutput, out templateSucceeded,
parentHandlerU, templateInfo, copyChild, copyParent);
if (superTrace)
{
StaticAIMLUtils.writeDebugLine("SuperTrace=" + templateSucceeded + ": " + templateInfo);
}
return(th);
}
catch (ChatSignalOverBudget ex)
{
throw;
}
catch (ChatSignal ex)
{
if (label.IsSignal(ex))
{
// if (ex.SubQuery != query) throw;
if (ex.NeedsAdding)
{
request.AddOutputSentences(templateInfo, ex.TemplateOutput, result, request.TopLevelScore);
}
templateSucceeded = ex.TemplateSucceeded;
createdOutput = ex.CreatedOutput;
return(ex.TagHandlerU);
}
throw;
}
catch (Exception ex)
{
throw;
}
finally
{
request.IsTraced = prevTraced;
request.Graph.UnTraced = untraced;
label.PopScope();
}
}
/// <summary>
/// Searches the CustomTag collection and processes the AIML if an appropriate tag handler is found
/// </summary>
/// <param name="user">the user who originated the request</param>
/// <param name="query">the query that produced targetBot node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="node">the node to evaluate</param>
/// <returns>the output Unifiable</returns>
static public AIMLTagHandler getBespokeTags(User user, SubQuery query, Request request, Result result, XmlNode node)
{
AltBot targetBot = query.TargetBot;
string nodename = node.Name.ToLower();
if (CustomTags != null)
{
//return null;
try
{
lock (CustomTags)
if (CustomTags.ContainsKey(nodename))
{
TagHandler customTagHandler = CustomTags[node.Name.ToLower()];
AIMLTagHandler newCustomTag = customTagHandler.Instantiate(LateBindingAssemblies, user,
query,
request, result, node, targetBot);
if (Equals(null, newCustomTag))
{
return(null);
}
else
{
return(newCustomTag);
}
}
}
catch (Exception e)
{
writeToLog("WARNING IN GET BESPOKE TAGS: " + e);
}
}
{
try
{
if (nodename.StartsWith("#"))
{
return(null);
}
String typeName = typeof(TagHandlerProcessor).Namespace + ".AIMLTagHandlers." + nodename;
Type t = Type.GetType(typeName);
if (t == null)
{
return(null);
}
ConstructorInfo c = t.GetConstructor(TagHandler.CONSTRUCTOR_TYPES);
return((AIMLTagHandler)c.Invoke(new object[] { targetBot, user, query, request, result, node }));
}
catch (Exception e)
{
writeToLog("ERROR getBespokeTags: " + e);
return(null);
}
}
}
/// <summary>
/// Given a request containing user input, produces a result from the bot
/// </summary>
/// <param name="request">the request from the user</param>
/// <returns>the result to be output to the user</returns>
public Result Chat(Request request)
{
Result result = new Result(request.User, this, request);
// Normalize the input
AIMLLoader loader = new AIMLLoader(this);
AimlStandard.Normalize.SplitIntoSentences splitter = new AimlStandard.Normalize.SplitIntoSentences(this);
string[] rawSentences = splitter.Transform(request.RawInput);
foreach (string sentence in rawSentences)
{
result.InputSentences.Add(sentence);
string path = loader.GeneratePath(sentence, request.User.GetLastBotOutput(), request.User.Topic, true);
result.NormalizedPaths.Add(path);
}
// grab the templates for the various sentences from the graphmaster
foreach (string path in result.NormalizedPaths)
{
string template = this.Graphmaster.Evaluate(path, request, MatchState.UserInput, new StringBuilder());
result.Templates.Add(template);
}
// process the templates into appropriate output
foreach (string template in result.Templates)
{
if (template.Length > 0)
{
try
{
XmlNode templateNode = AIMLTagHandler.GetNode(template);
string outputSentence = this.ProcessNode(templateNode, request, result, request.User);
if (outputSentence.Length > 0)
{
result.OutputSentences.Add(outputSentence);
}
}
catch (Exception e)
{
if (this.WillCallHome)
{
this.PhoneHome(e.Message, request);
}
this.WriteToLog("WARNING! A mal-formed template was encountered when trying to process the input: " + request.RawInput);
}
}
}
// populate the Result object
result.Duration = DateTime.Now - request.StartedOn;
request.User.AddResult(result);
return(result);
}
// Token: 0x06000072 RID: 114 RVA: 0x00004BAC File Offset: 0x00003BAC
protected override string ProcessChange()
{
if (this.templateNode.Name.ToLower() == "sr")
{
XmlNode node = AIMLTagHandler.getNode("<star/>");
star star = new star(this.bot, this.user, this.query, this.request, this.result, node);
string str = star.Transform();
XmlNode node2 = AIMLTagHandler.getNode("<srai>" + str + "</srai>");
srai srai = new srai(this.bot, this.user, this.query, this.request, this.result, node2);
return(srai.Transform());
}
return(string.Empty);
}
// Token: 0x06000018 RID: 24 RVA: 0x000025A0 File Offset: 0x000015A0
protected override string ProcessChange()
{
if (!(this.templateNode.Name.ToLower() == "sentence"))
{
return(string.Empty);
}
if (this.templateNode.InnerText.Length > 0)
{
StringBuilder stringBuilder = new StringBuilder();
char[] array = this.templateNode.InnerText.Trim().ToCharArray();
bool flag = true;
for (int i = 0; i < array.Length; i++)
{
string text = Convert.ToString(array[i]);
if (this.bot.Splitters.Contains(text))
{
flag = true;
}
Regex regex = new Regex("[a-zA-Z]");
if (regex.IsMatch(text))
{
if (flag)
{
stringBuilder.Append(text.ToUpper(this.bot.Locale));
flag = false;
}
else
{
stringBuilder.Append(text.ToLower(this.bot.Locale));
}
}
else
{
stringBuilder.Append(text);
}
}
return(stringBuilder.ToString());
}
XmlNode node = AIMLTagHandler.getNode("<star/>");
star star = new star(this.bot, this.user, this.query, this.request, this.result, node);
this.templateNode.InnerText = star.Transform();
if (this.templateNode.InnerText.Length > 0)
{
return(this.ProcessChange());
}
return(string.Empty);
}
/// <summary>
/// Searches the CustomTag collection and processes the AIML if an appropriate tag handler is found
/// </summary>
/// <param name="user">the user who originated the request</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="node">the node to evaluate</param>
/// <returns>the output string</returns>
private AIMLTagHandler GetBespokeTags(User user, Request request, Result result, XmlNode node)
{
if (this.CustomTags.ContainsKey(node.Name.ToLower()))
{
AIMLTagHandler customTagHandler = (AIMLTagHandler)this.CustomTags[node.Name.ToLower()];
customTagHandler.User = user;
customTagHandler.Request = request;
customTagHandler.Result = result;
customTagHandler.templateNode = node;
customTagHandler.Bot = this;
return(customTagHandler);
}
else
{
return(null);
}
}
internal AIMLTagHandler GetTagHandler(User user, SubQuery query, Request request, Result result, XmlNode node,
AIMLTagHandler parentTagHandlerU)
{
AltBot targetBot = user.bot;
AIMLTagHandler tag = targetBot.GetTagHandler(node, query, request, result, user, true);
if (query != null)
{
query.CurrentTagHandlerU = tag;
}
if (query != null)
{
query.CurrentNode = node;
}
if (tag == null)
{
writeToLog("NULL TAG " + node.OuterXml);
}
if (tag != null)
{
tag.SetParent(parentTagHandlerU);
if (query != null)
{
query.LastTagHandlerU = parentTagHandlerU ?? tag;
}
TemplateInfo ti = tag.templateInfo;
if (ti == null && query != null)
{
ti = query.CurrentTemplate;
}
if (ti == null && parentTagHandlerU != null)
{
ti = parentTagHandlerU.GetTemplateInfo();
}
if (ti != null)
{
tag.templateInfo = ti;
}
else
{
// writeToLog("DEBUG9 Missing templateInfo " + node.OuterXml);
}
}
return(tag);
}
/// <summary>
/// Should return the child tagHandler
/// </summary>
/// <param name="query"></param>
/// <param name="request"></param>
/// <param name="result"></param>
/// <param name="templateNode"></param>
/// <param name="sGuard"></param>
/// <param name="createdOutput"></param>
/// <param name="templateSucceeded"></param>
/// <param name="parentHandlerU"></param>
/// <param name="templateInfo"></param>
/// <param name="copyChild"></param>
/// <param name="copyParent"></param>
/// <returns></returns>
public AIMLTagHandler proccessResponse(SubQuery query,
Request request, Result result,
XmlNode templateNode, Unifiable sGuard,
out bool createdOutput, out bool templateSucceeded,
AIMLTagHandler parentHandlerU, TemplateInfo templateInfo,
bool copyChild, bool copyParent)
{
//request.CurrentResult = result;
query = query ?? request.CurrentQuery;
if (request.CurrentQuery == null)
{
request.CurrentQuery = query;
}
if (templateInfo == null)
{
// writeToLog("templateInfo is null " + templateNode);
}
templateInfo = templateInfo ?? query.CurrentTemplate;
//request.CurrentQuery = query;
if (!request.CanUseResultTemplate(templateInfo, result))
{
templateSucceeded = false;
createdOutput = false;
return(null);
}
// now cant use it again
if (templateInfo != null)
{
result.ResultTemplates.Add(templateInfo);
}
UndoStack undoStack = UndoStack.GetStackFor(query);
try
{
var childTagHandler = proccessTemplate(query, request, result, templateNode, sGuard,
out createdOutput, out templateSucceeded,
parentHandlerU, templateInfo, copyChild, copyParent);
return(childTagHandler);
}
finally
{
undoStack.UndoAll();
}
}
// Token: 0x06000016 RID: 22 RVA: 0x000024C8 File Offset: 0x000014C8
protected override string ProcessChange()
{
if (!(this.templateNode.Name.ToLower() == "person2"))
{
return(string.Empty);
}
if (this.templateNode.InnerText.Length > 0)
{
return(ApplySubstitutions.Substitute(this.bot, this.bot.Person2Substitutions, this.templateNode.InnerText));
}
XmlNode node = AIMLTagHandler.getNode("<star/>");
star star = new star(this.bot, this.user, this.query, this.request, this.result, node);
this.templateNode.InnerText = star.Transform();
if (this.templateNode.InnerText.Length > 0)
{
return(this.ProcessChange());
}
return(string.Empty);
}
public override float CanUnify(Unifiable with)
{
if (templateNode.NodeType == XmlNodeType.Text)
{
string srch = ToUpper(" " + with.ToValue(query) + " ");
return((ToUpper(" " + templateNode.InnerText + " ").Equals(srch)) ? STAR_TRUE : STAR_FALSE);
}
if (templateNode.HasChildNodes)
{
{
Unifiable rest = with;
// recursively check
foreach (XmlNode childNode in templateNode.ChildNodes)
{
with = rest.First;
rest = rest.Rest;
try
{
if (childNode.NodeType == XmlNodeType.Text)
{
string srch = ToUpper(" " + with.ToValue(query) + " ");
return((ToUpper(" " + templateNode.InnerText + " ").Equals(srch))
? STAR_TRUE
: STAR_FALSE);
}
AIMLTagHandler part = GetChildTagHandler(childNode);
if (part.CallCanUnify(with) > 0)
{
return(STAR_FALSE);
}
}
catch (Exception e)
{
AltBot.writeDebugLine("" + e);
}
}
return(IsNullOrEmpty(rest) ? STAR_TRUE : STAR_FALSE);
}
}
return(IsNullOrEmpty(with) ? STAR_TRUE : STAR_FALSE);
}
// Token: 0x06000090 RID: 144 RVA: 0x0000616C File Offset: 0x0000516C
public AIMLTagHandler getBespokeTags(User user, SubQuery query, Request request, Result result, XmlNode node)
{
if (!this.CustomTags.ContainsKey(node.Name.ToLower()))
{
return(null);
}
TagHandler tagHandler = this.CustomTags[node.Name.ToLower()];
AIMLTagHandler aimltagHandler = tagHandler.Instantiate(this.LateBindingAssemblies);
if (object.Equals(null, aimltagHandler))
{
return(null);
}
aimltagHandler.user = user;
aimltagHandler.query = query;
aimltagHandler.request = request;
aimltagHandler.result = result;
aimltagHandler.templateNode = node;
aimltagHandler.bot = this;
return(aimltagHandler);
}
public override float CanUnify(Unifiable with)
{
string srch = with.ToValue(query);
if (templateNode.NodeType == XmlNodeType.Text)
{
bool unifyWithTextNode = UnifyWithTextNode(templateNode, srch);
return(unifyWithTextNode ? AND_TRUE : AND_FALSE);
}
if (templateNode.HasChildNodes)
{
// recursively check
foreach (XmlNode childNode in templateNode.ChildNodes)
{
try
{
if (childNode.NodeType == XmlNodeType.Text)
{
return(UnifyWithTextNode(childNode, srch) ? AND_TRUE : AND_FALSE);
}
AIMLTagHandler part = GetChildTagHandler(childNode);
if (part.CallCanUnify(with) > 0)
{
return(AND_FALSE);
}
}
catch (Exception e)
{
Proc.writeToLog(e);
writeToLogWarn("" + e);
}
}
return(AND_TRUE);
}
return(AND_TRUE);
}
public AIMLTagHandler proccessResponse000(SubQuery query, Request request, Result result,
XmlNode sOutput, Unifiable sGuard,
out bool createdOutput, out bool templateSucceeded,
AIMLTagHandler parentHandlerU, TemplateInfo templateInfo,
bool copyChild, bool copyParent)
{
AltBot Proc = query.TargetBot;
//query.LastTagHandler = handler;
bool isTraced = request.IsTraced || request.IsTraced || !request.GraphsAcceptingUserInput ||
(templateInfo != null && templateInfo.IsTraced);
//XmlNode guardNode = AIMLTagHandler.getNode(s.Guard.InnerXml);
bool usedGuard = sGuard != null && sGuard.PatternNode != null;
sOutput = sOutput ?? templateInfo.ClonedOutput;
string output = sOutput.OuterXml;
XmlNode templateNode = sOutput;
bool childOriginal = true;
result.Started = true;
if (usedGuard)
{
output = "<template>" + sGuard.PatternNode.OuterXml + " GUARDBOM " + output +
"</template>";
templateNode = StaticAIMLUtils.getNodeAndSetSibling(false, output, false, false, sOutput);
childOriginal = false;
}
bool protectChild = copyChild || childOriginal;
bool suspendingLimits = request.IsToplevelRequest || request.SuspendSearchLimits;
AIMLTagHandler tagHandlerU = GetTagHandler(request.Requester, query, request, result,
templateNode, parentHandlerU);
string outputSentenceOut = processNode(templateNode, query,
request, result, request.Requester, parentHandlerU,
protectChild, copyParent, tagHandlerU, suspendingLimits, out templateSucceeded);
templateSucceeded = !StaticAIMLUtils.IsFalse(outputSentenceOut);
if (outputSentenceOut == null)
{
if (tagHandlerU == null)
{
writeToLog("tagHandler = null " + output);
}
else
{
bool success = false;
if (tagHandlerU.QueryHasSuceeded)
{
success = true;
}
if (tagHandlerU.QueryHasFailed)
{
success = false;
}
if (success)
{
writeToLog("Very BaD " + output);
}
else
{
}
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
}
outputSentenceOut = outputSentenceOut ?? "";
string left, outputSentence;
if (!StaticAIMLUtils.SplitOff(outputSentenceOut, "GUARDBOM", out left, out outputSentence))
{
left = null;
outputSentence = outputSentenceOut;
}
if (sGuard == null || sGuard.PatternNode != null)
{
string o = Proc.ToEnglish(outputSentence);
if (outputSentence.Trim().Length > 0)
{
templateSucceeded = true;
}
if (Proc.IsOutputSentence(o, outputSentence))
{
if (isTraced)
{
string aIMLLoaderParentTextAndSourceInfo = ParentTextAndSourceInfo(templateNode);
if (aIMLLoaderParentTextAndSourceInfo.Length > 300)
{
aIMLLoaderParentTextAndSourceInfo = TextFilter.ClipString(
aIMLLoaderParentTextAndSourceInfo, 300);
}
writeToLog("AIMLTRACE '{0}' IsOutputSentence={1}", o, aIMLLoaderParentTextAndSourceInfo);
}
createdOutput = true;
request.AddOutputSentences(templateInfo, o, result, request.TopLevelScore);
}
else
{
createdOutput = false;
}
// @TODO @HACK @BUG isTraced is a HORRID flag here!
if (false && !createdOutput && isTraced && request.GraphsAcceptingUserInput)
{
if (templateInfo != null)
{
string fromStr = " from " + templateInfo.Graph;
if (!StaticAIMLUtils.IsSilentTag(templateNode))
{
writeToLog("SILENT '{0}' TEMPLATE={1}", o, ParentTextAndSourceInfo(templateNode) + fromStr);
}
request.DisableTemplateUntilFinished(templateInfo);
}
else
{
writeToLog("UNUSED '{0}' TEMPLATE={1}", o, ParentTextAndSourceInfo(templateNode));
}
}
return(tagHandlerU);
}
try
{
templateSucceeded = !StaticAIMLUtils.IsFalse(left);
if (!templateSucceeded)
{
createdOutput = false;
return(tagHandlerU);
}
string lang = StaticXMLUtils.GetAttribValue(sGuard.PatternNode, "lang", "cycl").ToLower();
try
{
Unifiable ss = Proc.SystemExecute(left, lang, request);
if (StaticAIMLUtils.IsFalse(ss) || StaticAIMLUtils.IsNullOrEmpty(ss))
{
if (isTraced)
{
writeToLog("GUARD FALSE '{0}' TEMPLATE={1}", request,
ParentTextAndSourceInfo(templateNode));
}
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
else
{
templateSucceeded = true;
}
}
catch (ChatSignal e)
{
throw;
}
catch (Exception e)
{
Proc.writeToLog(e);
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
//part the BOM
string o = Proc.ToEnglish(outputSentence);
if (Proc.IsOutputSentence(o, outputSentence))
{
if (isTraced)
{
writeToLog(query.Graph + ": GUARD SUCCESS '{0}' TEMPLATE={1}", o,
ParentTextAndSourceInfo(templateNode));
}
templateSucceeded = true;
createdOutput = true;
request.AddOutputSentences(templateInfo, o, result, request.TopLevelScore);
return(tagHandlerU);
}
else
{
writeToLog("GUARD SKIP '{0}' TEMPLATE={1}", outputSentence,
ParentTextAndSourceInfo(templateNode));
}
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
catch (ChatSignal e)
{
throw;
}
catch (Exception ex)
{
Proc.writeToLog(ex);
templateSucceeded = false;
createdOutput = false;
return(tagHandlerU);
}
}
// Token: 0x0600008F RID: 143 RVA: 0x00005AE0 File Offset: 0x00004AE0
private string processNode(XmlNode node, SubQuery query, Request request, Result result, User user)
{
if (request.StartedOn.AddMilliseconds(request.bot.TimeOut) < DateTime.Now)
{
request.bot.writeToLog(string.Concat(new string[]
{
"WARNING! Request timeout. User: "******" raw input: \"",
request.rawInput,
"\" processing template: \"",
query.Template,
"\""
}));
request.hasTimedOut = true;
return(string.Empty);
}
string text = node.Name.ToLower();
if (text == "template")
{
StringBuilder stringBuilder = new StringBuilder();
if (node.HasChildNodes)
{
foreach (object obj in node.ChildNodes)
{
XmlNode node2 = (XmlNode)obj;
stringBuilder.Append(this.processNode(node2, query, request, result, user));
}
}
return(stringBuilder.ToString());
}
AIMLTagHandler aimltagHandler = null;
aimltagHandler = this.getBespokeTags(user, query, request, result, node);
if (object.Equals(null, aimltagHandler))
{
string key;
switch (key = text)
{
case "bot":
aimltagHandler = new bot(this, user, query, request, result, node);
goto IL_53F;
case "condition":
aimltagHandler = new condition(this, user, query, request, result, node);
goto IL_53F;
case "date":
aimltagHandler = new date(this, user, query, request, result, node);
goto IL_53F;
case "formal":
aimltagHandler = new formal(this, user, query, request, result, node);
goto IL_53F;
case "gender":
aimltagHandler = new gender(this, user, query, request, result, node);
goto IL_53F;
case "get":
aimltagHandler = new get(this, user, query, request, result, node);
goto IL_53F;
case "gossip":
aimltagHandler = new gossip(this, user, query, request, result, node);
goto IL_53F;
case "id":
aimltagHandler = new id(this, user, query, request, result, node);
goto IL_53F;
case "input":
aimltagHandler = new input(this, user, query, request, result, node);
goto IL_53F;
case "javascript":
aimltagHandler = new javascript(this, user, query, request, result, node);
goto IL_53F;
case "learn":
aimltagHandler = new learn(this, user, query, request, result, node);
goto IL_53F;
case "lowercase":
aimltagHandler = new lowercase(this, user, query, request, result, node);
goto IL_53F;
case "person":
aimltagHandler = new person(this, user, query, request, result, node);
goto IL_53F;
case "person2":
aimltagHandler = new person2(this, user, query, request, result, node);
goto IL_53F;
case "random":
aimltagHandler = new random(this, user, query, request, result, node);
goto IL_53F;
case "sentence":
aimltagHandler = new sentence(this, user, query, request, result, node);
goto IL_53F;
case "set":
aimltagHandler = new set(this, user, query, request, result, node);
goto IL_53F;
case "size":
aimltagHandler = new size(this, user, query, request, result, node);
goto IL_53F;
case "sr":
aimltagHandler = new sr(this, user, query, request, result, node);
goto IL_53F;
case "srai":
aimltagHandler = new srai(this, user, query, request, result, node);
goto IL_53F;
case "star":
aimltagHandler = new star(this, user, query, request, result, node);
goto IL_53F;
case "system":
aimltagHandler = new system(this, user, query, request, result, node);
goto IL_53F;
case "that":
aimltagHandler = new that(this, user, query, request, result, node);
goto IL_53F;
case "thatstar":
aimltagHandler = new thatstar(this, user, query, request, result, node);
goto IL_53F;
case "think":
aimltagHandler = new think(this, user, query, request, result, node);
goto IL_53F;
case "topicstar":
aimltagHandler = new topicstar(this, user, query, request, result, node);
goto IL_53F;
case "uppercase":
aimltagHandler = new uppercase(this, user, query, request, result, node);
goto IL_53F;
case "version":
aimltagHandler = new version(this, user, query, request, result, node);
goto IL_53F;
}
aimltagHandler = null;
}
IL_53F:
if (object.Equals(null, aimltagHandler))
{
return(node.InnerText);
}
if (aimltagHandler.isRecursive)
{
if (node.HasChildNodes)
{
foreach (object obj2 in node.ChildNodes)
{
XmlNode xmlNode = (XmlNode)obj2;
if (xmlNode.NodeType != XmlNodeType.Text)
{
xmlNode.InnerXml = this.processNode(xmlNode, query, request, result, user);
}
}
}
return(aimltagHandler.Transform());
}
string str = aimltagHandler.Transform();
XmlNode node3 = AIMLTagHandler.getNode("<node>" + str + "</node>");
if (node3.HasChildNodes)
{
StringBuilder stringBuilder2 = new StringBuilder();
foreach (object obj3 in node3.ChildNodes)
{
XmlNode node4 = (XmlNode)obj3;
stringBuilder2.Append(this.processNode(node4, query, request, result, user));
}
return(stringBuilder2.ToString());
}
return(node3.InnerXml);
}
public TagHtml RenderTagToHtml(string tagName, string outerTagContent, string innerTagContent)
{
StringBuilder sb = new StringBuilder();
string dataText = "";
switch (tagName)
{
case "button":
if (outerTagContent.Contains("<postback>"))
{
string dataPostback = new Regex("<postback>(.*)</postback>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
dataText = new Regex("<text>(.*)</text>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
sb.AppendLine(" <div class=\"_2zgz _2zgz_postback\">");
sb.AppendLine(" <div class=\"_4bqf _6biq _6bir\" tabindex=\"0\" role=\"button\" data-postback =\"" + dataPostback + "\" style=\"border-color:" + _color + " color:" + _color + "\">" + dataText + "</div>");
sb.AppendLine(" </div>");
_tagHtml.Body = "";
_tagHtml.ButtonPostback = sb.ToString();
}
else if (outerTagContent.Contains("<url>"))
{
dataText = new Regex("<text>(.*)</text>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
string dataUrl = new Regex("<url>(.*)</url>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
sb.AppendLine("<div class=\"_6ir5\">");
sb.AppendLine(" <div class=\"_4bqf _6ir3\">");
sb.AppendLine(" <a class=\"_6ir4 _6ir4_url\" target=\"_blank\" href=\"" + dataUrl + "\" style=\"color:" + _color + "\">" + dataText + "</a>");
sb.AppendLine(" </div>");
sb.AppendLine("</div>");
_tagHtml.Body = sb.ToString();
}
else if (outerTagContent.Contains("<menu>"))
{
dataText = new Regex("<text>(.*)</text>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
string dataMenu = new Regex("<menu>(.*)</menu>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
//if (_isFlag)
//{
// sb.AppendLine("<div class=\"_6isd _6ir5\">");
//}else
//{
// sb.AppendLine("<div class=\"_6ir5\">");
//}
sb.AppendLine("<div class=\"_6ir5\">");
sb.AppendLine(" <div class=\"_4bqf _6ir3\">");
sb.AppendLine(" <a class=\"_6ir4 _6ir4_menu\" data-postback =\"" + dataMenu + "\" href=\"#\" style=\"color:" + _color + "\">" + dataText + "</a>");
sb.AppendLine(" </div>");
sb.AppendLine("</div>");
//_isFlag = false;
_tagHtml.Body = sb.ToString();
}
else if (outerTagContent.Contains("<module>"))
{
dataText = new Regex("<text>(.*)</text>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
string dataModule = new Regex("<module>(.*)</module>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
//if (_isFlag)
//{
// sb.AppendLine("<div class=\"_6isd _6ir5\">");
//}else
//{
// sb.AppendLine("<div class=\"_6ir5\">");
//}
sb.AppendLine("<div class=\"_6ir5\">");
sb.AppendLine(" <div class=\"_4bqf _6ir3\">");
sb.AppendLine(" <a class=\"_6ir4 _6ir4_menu\" data-postback =\"" + dataModule + "\" href=\"#\" style=\"color:" + _color + "\">" + dataText + "</a>");
sb.AppendLine(" </div>");
sb.AppendLine("</div>");
//_isFlag = false;
_tagHtml.Body = sb.ToString();
}
break;
case "link":
dataText = new Regex("<text>(.*)</text>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
string dataLink = new Regex("<url>(.*)</url>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
sb.AppendLine("<div class=\"_6j0y\">");
sb.AppendLine(" <a target=\"_blank\" href=\"" + dataLink + "\">");
sb.AppendLine(" " + dataText + "");
sb.AppendLine(" </a>");
sb.AppendLine("</div>");
_tagHtml.Body = sb.ToString();
break;
case "image":
//Common.ReadString("Domain") host domain lay tu`appconfig cua domain cha truyen` vao`
string dataImage = new Regex("<image>(.*)</image>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
sb.AppendLine("<div class=\"_6j0s\" style=\"background-image:url("" + Common.ReadString("Domain") + dataImage + ""); background-position: center center; height: 150px; width: 100%;\"></div>");
_tagHtml.Body = sb.ToString();
break;
case "title":
string dataTitle = new Regex("<title>(.*)</title>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
sb.AppendLine("<div class=\"_6j0t _4ik4 _4ik5 _6j0t_title\" style=\"-webkit-line-clamp: 3;\">");
sb.AppendLine("" + dataTitle + "");
sb.AppendLine("</div>");
_tagHtml.Body = sb.ToString();
break;
case "subtitle":
string dataSubTitle = new Regex("<subtitle>(.*)</subtitle>", RegexOptions.IgnoreCase).Match(outerTagContent).Groups[1].Value;
sb.Append("<div class=\"_6j0v _6j0v_subtitle\">");
sb.AppendLine(" <div class=\"_6j0u _6j0w\">");
sb.AppendLine(" " + dataSubTitle + "");
sb.AppendLine(" </div>");
sb.AppendLine(" <div class=\"_6j0u _6j0x _4ik4 _4ik5\" style=\"-webkit-line-clamp: 2;\">");
sb.AppendLine(" <div>");
sb.AppendLine(" " + dataSubTitle + "");
sb.AppendLine(" </div>");
sb.AppendLine(" </div>");
sb.AppendLine(" </div>");
_tagHtml.Body = sb.ToString();
break;
default:
_tagHtml.Body = String.Empty;
break;
}
if (tagName == "card")
{
XmlNode resultNode = AIMLTagHandler.getNode("<node>" + innerTagContent + "</node>");
if (resultNode.HasChildNodes)
{
StringBuilder sbBtnPostback = new StringBuilder();
StringBuilder sbCard = new StringBuilder();
sbCard.AppendLine("<div class=\"_6j2i\">");
string htmlCard = "";
foreach (XmlNode cNode in resultNode.ChildNodes)
{
htmlCard = RenderTagToHtml(cNode.Name, cNode.OuterXml, "").Body;
if (cNode.Name == "title")
{
htmlCard = "<div class=\"_6j2g\">" + htmlCard;
}
if (cNode.Name == "link")
{
htmlCard = htmlCard + "</div>";
}
if (cNode.Name == "button")
{
if (cNode.OuterXml.Contains("<postback>"))
{
_tagHtml.TotalBtnPostback = _tagHtml.TotalBtnPostback + 1;
}
}
sbCard.AppendLine(htmlCard);
sbBtnPostback.AppendLine(RenderTagToHtml(cNode.Name, cNode.OuterXml, "").ButtonPostback);
}
sbCard.AppendLine("</div>");
_tagHtml.Body = sbCard.ToString();
_tagHtml.ButtonPostback = sbBtnPostback.ToString();
}
}
if (tagName == "carousel")
{
XmlNode resultNode = AIMLTagHandler.getNode("<node>" + innerTagContent + "</node>");
StringBuilder sbCarousel = new StringBuilder();
if (resultNode.HasChildNodes)
{
foreach (XmlNode cNode in resultNode.ChildNodes)
{
sbCarousel.AppendLine("<div class=\"_2zgz\"> <div class=\"_6j2h\">" + RenderTagToHtml(cNode.Name, cNode.OuterXml, cNode.InnerXml).Body + "</div></div>");
_tagHtml.TotalCarousel = _tagHtml.TotalCarousel + 1;
}
_tagHtml.Body = sbCarousel.ToString();
}
}
return(_tagHtml);
}
/// <summary>
/// Recursively evaluates the template nodes returned from the Proccessor
/// </summary>
/// <param name="node">the node to evaluate</param>
/// <param name="query">the query that produced targetBot node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="user">the user who originated the request</param>
/// <returns>the output Unifiable</returns>
public string processNodeVV(XmlNode node, SubQuery query,
Request request, Result result, User user,
AIMLTagHandler parentHandlerU, bool protectChild, bool copyParent,
AIMLTagHandler tagHandlerU, out bool childSuccess)
{
AltBot TargetBot = tagHandlerU.bot;
if (request != null)
{
TargetBot = request.TargetBot;
}
childSuccess = true;
if (node == null)
{
string whyError = "ERROR null NODE " + tagHandlerU;
writeToLog(whyError);
throw new ChatSignalOverBudget(request, whyError);
}
if (node.NodeType == XmlNodeType.Text)
{
childSuccess = true;
if (tagHandlerU != null)
{
tagHandlerU.QueryHasSuceeded = true;
}
string s = StaticAIMLUtils.Trim(StaticAIMLUtils.TextNodeValue(node));
if (!String.IsNullOrEmpty(s))
{
return(StaticAIMLUtils.ValueText(s));
}
//return s;
}
if (tagHandlerU == null)
{
string whyError = "ERROR null THND " + node;
childSuccess = false;
writeToLog(whyError);
}
bool isTraced = (request != null && (request.IsTraced || !request.GraphsAcceptingUserInput)) ||
(query != null && query.IsTraced);
// check for timeout (to avoid infinite loops)
bool overBudget = false;
if (request != null && request.IsComplete(result))
{
object gn = request.Graph;
if (query != null)
{
gn = query.Graph;
}
string s = StaticAIMLUtils.SafeFormat("WARNING! Request " + request.WhyComplete +
". User: {0} raw input: {3} \"{1}\" processing {2} templates: \"{4}\"",
request.Requester.UserID, Unifiable.DescribeUnifiable(request.rawInput),
(query == null ? "-NOQUERY-" : query.Templates.Count.ToString()), gn, node);
if (isTraced)
{
request.writeToLog(s);
}
overBudget = true;
if (!request.IsToplevelRequest)
{
throw new ChatSignalOverBudget(request, s);
}
}
// process the node
if (ReferenceEquals(null, tagHandlerU))
{
childSuccess = true;
if (node.NodeType == XmlNodeType.Comment)
{
return(Unifiable.Empty);
}
if (node.NodeType == XmlNodeType.Text)
{
string s = StaticAIMLUtils.Trim(StaticAIMLUtils.TextNodeValue(node));
if (String.IsNullOrEmpty(s))
{
return(Unifiable.Empty);
}
return(s);
}
// ReSharper disable ConditionIsAlwaysTrueOrFalse
OutputDelegate del = (request != null) ? request.writeToLog : writeToLog;
// ReSharper restore ConditionIsAlwaysTrueOrFalse
if (overBudget)
{
return(Unifiable.Empty);
}
string nodeInner = node.InnerXml;
TargetBot.EvalAiml(node, request, del ?? TextPatternUtils.DEVNULL);
return(node.InnerXml);
}
XmlNode oldNode = node;
bool wasReadonlyNode = oldNode.IsReadOnly;
// copy the node!?!
if (protectChild)
{
copyParent = true;
LineInfoElementImpl newnode = StaticAIMLUtils.CopyNode(node, copyParent);
newnode.ReadOnly = false;
node = newnode;
}
if (overBudget)
{
tagHandlerU.Dispose();
tagHandlerU = null;
childSuccess = true;
return(Unifiable.Empty);
}
tagHandlerU.SetParent(parentHandlerU);
//if (parent!=null) parent.AddChild(tagHandler);
Unifiable cp = tagHandlerU.Transform();
if (Unifiable.IsNullOrEmpty(cp) && (!tagHandlerU.QueryHasSuceeded || tagHandlerU.QueryHasFailed))
{
bool needsOneMoreTry = !request.SuspendSearchLimits &&
(request.IsToplevelRequest /*|| result.ParentRequest.IsToplevelRequest*/);
if (isTraced || needsOneMoreTry)
{
//writeDebugLine("ERROR: Try Again since NULL " + tagHandler);
bool wsl = request.SuspendSearchLimits;
try
{
request.SuspendSearchLimits = true;
cp = tagHandlerU.Transform();
if (Unifiable.IsNull(cp))
{
childSuccess = false;
return(tagHandlerU.GetTemplateNodeInnerText());
}
if (false && Unifiable.IsNullOrEmpty(cp))
{
// trace the next line to see why
AIMLTagHandler handlerU = tagHandlerU;
TargetBot.TraceTest("ERROR: Try Again since NULL " + handlerU,
() => { cp = handlerU.Transform(); });
}
}
finally
{
request.SuspendSearchLimits = wsl;
}
}
}
if (tagHandlerU.QueryHasFailed)
{
childSuccess = false;
return(tagHandlerU.FAIL);
}
childSuccess = !tagHandlerU.QueryHasFailed;
if (!childSuccess)
{
}
var st = StaticAIMLUtils.IsSilentTag(node);
var ine = Unifiable.IsNullOrEmpty(cp);
if (!ine || st)
{
childSuccess = true;
return(cp);
}
if (Unifiable.IsNull(cp))
{
cp = tagHandlerU.GetTemplateNodeInnerText();
if (tagHandlerU.QueryHasSuceeded)
{
childSuccess = true;
return(cp);
}
return(cp);
}
return(cp);
}
/// <summary>
/// Recursively evaluates the template nodes returned from the bot
/// </summary>
/// <param name="node">the node to evaluate</param>
/// <param name="query">the query that produced this node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="user">the user who originated the request</param>
/// <returns>the output string</returns>
private string ProcessNode(XmlNode node, SubQuery query, Request request, Result result, User user)
{
// check for timeout (to avoid infinite loops)
if (request.StartedOn.AddMilliseconds(_config.TimeOut) < DateTime.Now)
{
//_logger.LogWarning("Request timeout. User: "******" raw input: \"" + request.rawInput + "\" processing template: \""+query.Template+"\"");
request.HasTimedOut = true;
return(string.Empty);
}
// process the node
string tagName = node.Name.ToLower();
if (tagName == "template")
{
StringBuilder templateResult = new StringBuilder();
if (node.HasChildNodes)
{
// recursively check
foreach (XmlNode childNode in node.ChildNodes)
{
templateResult.Append(ProcessNode(childNode, query, request, result, user));
}
}
return(templateResult.ToString());
}
else
{
AIMLTagHandler tagHandler = _tagFactory.CreateTagHandler(tagName, this, user, query, request, result, node);
if (object.Equals(null, tagHandler))
{
return(node.InnerText);
}
else
{
if (tagHandler.isRecursive)
{
if (node.HasChildNodes)
{
// recursively check
foreach (XmlNode childNode in node.ChildNodes)
{
if (childNode.NodeType != XmlNodeType.Text)
{
childNode.InnerXml = ProcessNode(childNode, query, request, result, user);
}
}
}
return(tagHandler.Transform());
}
else
{
string resultNodeInnerXML = tagHandler.Transform();
XmlNode resultNode = AIMLTagHandler.GetNode("<node>" + resultNodeInnerXML + "</node>");
if (resultNode.HasChildNodes)
{
StringBuilder recursiveResult = new StringBuilder();
// recursively check
foreach (XmlNode childNode in resultNode.ChildNodes)
{
recursiveResult.Append(ProcessNode(childNode, query, request, result, user));
}
return(recursiveResult.ToString());
}
else
{
return(resultNode.InnerXml);
}
}
}
}
}
/// <summary>
/// Given a request containing user input, produces a result from the bot
/// </summary>
/// <param name="request">the request from the user</param>
/// <returns>the result to be output to the user</returns>
public Result Chat(Request request)
{
Result result = new Result(request);
if (_config.isAcceptingUserInput)
{
// Normalize the input
ReniBot.AimlEngine.Normalize.SplitIntoSentences splitter = new ReniBot.AimlEngine.Normalize.SplitIntoSentences(_config);
string[] rawSentences = splitter.Transform(request.RawInput);
foreach (string sentence in rawSentences)
{
result.InputSentences.Add(sentence);
string topic = _botUserService.GetTopic(request.UserId);
string lastOutput = _userResultService.GetLastOutput(request.UserId);
string path = _loader.GeneratePath(sentence, lastOutput, topic, true);
result.NormalizedPaths.Add(path);
}
// grab the templates for the various sentences from the graphmaster
foreach (string path in result.NormalizedPaths)
{
Utils.SubQuery query = new SubQuery(path);
query.Template = _graphmaster.Evaluate(path, query, request, MatchState.UserInput, new StringBuilder(), _config.TimeOut);
result.HasTimedOut = request.HasTimedOut;
result.SubQueries.Add(query);
}
// process the templates into appropriate output
foreach (SubQuery query in result.SubQueries)
{
if (query.Template.Length > 0)
{
try
{
XmlNode templateNode = AIMLTagHandler.GetNode(query.Template);
string outputSentence = ProcessNode(templateNode, query, request, result, new User(_predicateService, _userResultService, _requestService)
{
UserId = request.UserId
});
if (outputSentence.Length > 0)
{
result.OutputSentences.Add(outputSentence);
}
}
catch (Exception e)
{
if (_config.WillCallHome)
{
PhoneHome(e.Message, request);
}
_logger.LogWarning("A problem was encountered when trying to process the input: " + request.RawInput + " with the template: \"" + query.Template + "\"");
}
}
}
}
else
{
result.OutputSentences.Add(_config.NotAcceptingUserInputMessage);
}
// populate the Result object
result.Duration = DateTime.Now - request.StartedOn;
_userResultService.Add(result.Duration.Milliseconds, result.HasTimedOut, result.RawOutput, result.RequestId, result.UserId);
return(result);
}
/// <summary>
/// Recursively evaluates the template nodes returned from the bot
/// </summary>
/// <param name="node">the node to evaluate</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="user">the user who originated the request</param>
/// <returns>the output string</returns>
private string ProcessNode(XmlNode node, Request request, Result result, User user)
{
StringBuilder newInnerText = new StringBuilder();
if (node.HasChildNodes)
{
// recursively check
foreach (XmlNode childNode in node.ChildNodes)
{
childNode.InnerText = this.ProcessNode(childNode, request, result, user);
}
}
// process the node itself
AIMLTagHandler tagHandler = null;
switch (node.Name.ToLower())
{
case "bot":
tagHandler = new BotTag(this, user, request, result, node);
break;
case "condition":
tagHandler = new ConditionTag(this, user, request, result, node);
break;
case "date":
tagHandler = new DateTag(this, user, request, result, node);
break;
case "formal":
tagHandler = new FormalTag(this, user, request, result, node);
break;
case "gender":
tagHandler = new GenderTag(this, user, request, result, node);
break;
case "get":
tagHandler = new GetTag(this, user, request, result, node);
break;
case "gossip":
tagHandler = new GossipTag(this, user, request, result, node);
break;
case "id":
tagHandler = new IdTag(this, user, request, result, node);
break;
case "input":
tagHandler = new InputTag(this, user, request, result, node);
break;
case "javascript":
tagHandler = new JavascriptTag(this, user, request, result, node);
break;
case "learn":
tagHandler = new LearnTag(this, user, request, result, node);
break;
case "lowercase":
tagHandler = new LowercaseTag(this, user, request, result, node);
break;
case "person":
tagHandler = new PersonTag(this, user, request, result, node);
break;
case "person2":
tagHandler = new Person2Tag(this, user, request, result, node);
break;
case "random":
tagHandler = new RandomTag(this, user, request, result, node);
break;
case "sentence":
tagHandler = new SentenceTag(this, user, request, result, node);
break;
case "set":
tagHandler = new SetTag(this, user, request, result, node);
break;
case "size":
tagHandler = new SizeTag(this, user, request, result, node);
break;
case "sr":
tagHandler = new SrTag(this, user, request, result, node);
break;
case "srai":
tagHandler = new SraiTag(this, user, request, result, node);
break;
case "star":
tagHandler = new StarTag(this, user, request, result, node);
break;
case "system":
tagHandler = new SystemTag(this, user, request, result, node);
break;
case "that":
tagHandler = new ThatTag(this, user, request, result, node);
break;
case "thatstar":
tagHandler = new ThatStarTag(this, user, request, result, node);
break;
case "think":
tagHandler = new ThinkTag(this, user, request, result, node);
break;
case "topicstar":
tagHandler = new TopicStarTag(this, user, request, result, node);
break;
case "uppercase":
tagHandler = new UppercaseTag(this, user, request, result, node);
break;
case "version":
tagHandler = new VersionTag(this, user, request, result, node);
break;
default:
tagHandler = this.GetBespokeTags(user, request, result, node);
break;
}
if (object.Equals(null, tagHandler))
{
return(node.InnerText);
}
else
{
return(tagHandler.Transform());
}
}
/// <summary>
/// Recursively evaluates the template nodes returned from the bot
/// </summary>
/// <param name="node">the node to evaluate</param>
/// <param name="query">the query that produced this node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="user">the user who originated the request</param>
/// <returns>the output string</returns>
private string ProcessNode(XmlNode node, SubQuery query, Request request, Result result, User user)
{
// check for timeout (to avoid infinite loops)
if (request.StartedOn.AddMilliseconds(request.Bot.TimeOut) < DateTime.Now)
{
request.Bot.WriteToLog("WARNING! Request timeout. User: "******" raw input: \"" + request.RawInput + "\" processing template: \"" + query.Template + "\"");
request.HasTimedOut = true;
return(string.Empty);
}
// process the node
string tagName = node.Name.ToLower();
if (tagName == "template")
{
StringBuilder templateResult = new StringBuilder();
if (node.HasChildNodes)
{
// recursively check
foreach (XmlNode childNode in node.ChildNodes)
{
templateResult.Append(ProcessNode(childNode, query, request, result, user));
}
}
return(templateResult.ToString());
}
else
{
AIMLTagHandler tagHandler = null;
tagHandler = getBespokeTags(user, query, request, result, node);
if (Equals(null, tagHandler))
{
switch (tagName)
{
case "bot":
tagHandler = new AIMLTagHandlers.Bot(this, user, query, request, result, node);
break;
case "condition":
tagHandler = new AIMLTagHandlers.Condition(this, user, query, request, result, node);
break;
case "date":
tagHandler = new AIMLTagHandlers.Date(this, user, query, request, result, node);
break;
case "formal":
tagHandler = new AIMLTagHandlers.Formal(this, user, query, request, result, node);
break;
case "gender":
tagHandler = new AIMLTagHandlers.Gender(this, user, query, request, result, node);
break;
case "get":
tagHandler = new AIMLTagHandlers.Get(this, user, query, request, result, node);
break;
case "gossip":
tagHandler = new AIMLTagHandlers.Gossip(this, user, query, request, result, node);
break;
case "id":
tagHandler = new AIMLTagHandlers.Id(this, user, query, request, result, node);
break;
case "input":
tagHandler = new AIMLTagHandlers.Input(this, user, query, request, result, node);
break;
case "javascript":
tagHandler = new AIMLTagHandlers.Javascript(this, user, query, request, result, node);
break;
case "learn":
tagHandler = new AIMLTagHandlers.Learn(this, user, query, request, result, node);
break;
case "lowercase":
tagHandler = new AIMLTagHandlers.Lowercase(this, user, query, request, result, node);
break;
case "person":
tagHandler = new AIMLTagHandlers.Person(this, user, query, request, result, node);
break;
case "person2":
tagHandler = new AIMLTagHandlers.Person2(this, user, query, request, result, node);
break;
case "random":
tagHandler = new AIMLTagHandlers.Random(this, user, query, request, result, node);
break;
case "sentence":
tagHandler = new AIMLTagHandlers.Sentence(this, user, query, request, result, node);
break;
case "set":
tagHandler = new AIMLTagHandlers.Set(this, user, query, request, result, node);
break;
case "size":
tagHandler = new AIMLTagHandlers.Size(this, user, query, request, result, node);
break;
case "sr":
tagHandler = new AIMLTagHandlers.Sr(this, user, query, request, result, node);
break;
case "srai":
tagHandler = new AIMLTagHandlers.Srai(this, user, query, request, result, node);
break;
case "star":
tagHandler = new AIMLTagHandlers.Star(this, user, query, request, result, node);
break;
case "system":
tagHandler = new AIMLTagHandlers.System(this, user, query, request, result, node);
break;
case "that":
tagHandler = new AIMLTagHandlers.That(this, user, query, request, result, node);
break;
case "thatstar":
tagHandler = new AIMLTagHandlers.ThatStar(this, user, query, request, result, node);
break;
case "think":
tagHandler = new AIMLTagHandlers.Think(this, user, query, request, result, node);
break;
case "topicstar":
tagHandler = new AIMLTagHandlers.TopicStar(this, user, query, request, result, node);
break;
case "uppercase":
tagHandler = new AIMLTagHandlers.Uppercase(this, user, query, request, result, node);
break;
case "version":
tagHandler = new AIMLTagHandlers.Version(this, user, query, request, result, node);
break;
default:
tagHandler = null;
break;
}
}
if (Equals(null, tagHandler))
{
return(node.InnerText);
}
else
{
if (tagHandler.IsRecursive)
{
if (node.HasChildNodes)
{
// recursively check
foreach (XmlNode childNode in node.ChildNodes)
{
if (childNode.NodeType != XmlNodeType.Text)
{
childNode.InnerXml = ProcessNode(childNode, query, request, result, user);
}
}
}
return(tagHandler.Transform());
}
else
{
string resultNodeInnerXML = tagHandler.Transform();
XmlNode resultNode = AIMLTagHandler.GetNode("<node>" + resultNodeInnerXML + "</node>");
if (resultNode.HasChildNodes)
{
StringBuilder recursiveResult = new StringBuilder();
// recursively check
foreach (XmlNode childNode in resultNode.ChildNodes)
{
recursiveResult.Append(ProcessNode(childNode, query, request, result, user));
}
return(recursiveResult.ToString());
}
else
{
return(resultNode.InnerXml);
}
}
}
}
}
internal AIMLTagHandler GetTagHandlerU(User user, SubQuery query, Request request, Result result, XmlNode node, bool liText)
{
AIMLTagHandler tagHandlerU = getBespokeTags(user, query, request, result, node);
string nodeNameLower = StaticAIMLUtils.ToLower(node.LocalName);
AltBot targetBot = query.TargetBot;
if (Equals(null, tagHandlerU))
{
switch (nodeNameLower)
{
case "template":
case "answer": //CML
tagHandlerU = new template(targetBot, user, query, request, result, node);
break;
case "aiml":
case "cml": //CML
tagHandlerU = new aiml(targetBot, user, query, request, result, node);
break;
case "aimlexec":
case "eval":
tagHandlerU = new aimlexec(targetBot, user, query, request, result, node);
break;
case "vars":
case "root":
case "predicates": //CML
tagHandlerU = new root(targetBot, user, query, request, result, node, (() => query.TargetSettings));
break;
case "properties":
case "bots":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.GlobalSettings));
break;
case "substitutions":
tagHandlerU = new root(targetBot, user, query, request, result, node,
(() => request.TargetBot.InputSubstitutions));
break;
case "topic":
case "conversation": //CML
tagHandlerU = new topic(targetBot, user, query, request, result, node);
break;
case "category":
case "conv": //CML
tagHandlerU = new category(targetBot, user, query, request, result, node);
break;
case "and":
tagHandlerU = new and(targetBot, user, query, request, result, node);
break;
case "or":
tagHandlerU = new or(targetBot, user, query, request, result, node);
break;
case "optional":
tagHandlerU = new optional(targetBot, user, query, request, result, node);
break;
case "isa":
tagHandlerU = new isa(targetBot, user, query, request, result, node);
break;
case "bot":
tagHandlerU = new bot(targetBot, user, query, request, result, node);
break;
case "condition":
case "options": //cml
tagHandlerU = new condition_aima(targetBot, user, query, request, result, node);
break;
case "li":
if (liText)
{
tagHandlerU = new liif(targetBot, user, query, request, result, node);
}
break;
case "if":
tagHandlerU = new liif(targetBot, user, query, request, result, node);
break;
case "personf":
tagHandlerU = new format(targetBot, user, query, request, result, node,
new Func <string, string>(HttpUtility.UrlEncode),
null);
break;
case "date":
tagHandlerU = new date(targetBot, user, query, request, result, node);
break;
case "formal":
tagHandlerU = new formal(targetBot, user, query, request, result, node);
break;
case "gender":
tagHandlerU = new gender(targetBot, user, query, request, result, node);
break;
case "get":
tagHandlerU = new get(targetBot, user, query, request, result, node);
break;
case "gossip":
tagHandlerU = new gossip(targetBot, user, query, request, result, node);
break;
case "get_ip":
case "id":
tagHandlerU = new id(targetBot, user, query, request, result, node);
break;
case "inputreq":
tagHandlerU = new inputreq(targetBot, user, query, request, result, node);
break;
case "request":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "input":
tagHandlerU = new input(targetBot, user, query, request, result, node, 1);
break;
case "justthat": // <input index="2"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 2);
break;
case "beforethat": // <input index="3"/>
tagHandlerU = new input(targetBot, user, query, request, result, node, 3);
break;
#if !(__MonoCS__)
case "javascript":
tagHandlerU = new javascript(targetBot, user, query, request, result, node);
break;
#endif
case "learn":
case "load":
case "noload": // the commented version of <load>
tagHandlerU = new learn(targetBot, user, query, request, result, node);
break;
case "lowercase":
tagHandlerU = new lowercase(targetBot, user, query, request, result, node);
break;
case "person":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "person2":
tagHandlerU = new substitute(targetBot, user, query, request, result, node);
break;
case "random":
tagHandlerU = new random(targetBot, user, query, request, result, node);
break;
case "sentence":
tagHandlerU = new sentence(targetBot, user, query, request, result, node);
break;
case "set":
tagHandlerU = new set(targetBot, user, query, request, result, node);
break;
case "size":
case "getsize":
tagHandlerU = new size(targetBot, user, query, request, result, node);
break;
case "sr":
tagHandlerU = new sr(targetBot, user, query, request, result, node);
break;
case "srai_odd":
tagHandlerU = new srai_odd(targetBot, user, query, request, result, node);
break;
case "star":
tagHandlerU = new star(targetBot, user, query, request, result, node);
break;
case "system":
tagHandlerU = new system(targetBot, user, query, request, result, node);
break;
case "that": //default <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 1);
break;
case "justbeforethat": //treated as <that index="2,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "response": //treated as <that index="1,1"/>
tagHandlerU = new that(targetBot, user, query, request, result, node, 2);
break;
case "thatstar":
tagHandlerU = new thatstar(targetBot, user, query, request, result, node);
break;
case "think":
tagHandlerU = new think(targetBot, user, query, request, result, node);
break;
case "topicstar":
tagHandlerU = new topicstar(targetBot, user, query, request, result, node);
break;
case "uppercase":
tagHandlerU = new uppercase(targetBot, user, query, request, result, node);
break;
case "version":
case "getversion":
tagHandlerU = new version(targetBot, user, query, request, result, node);
break;
case "cycsystem":
tagHandlerU = new cycsystem(targetBot, user, query, request, result, node);
break;
case "cycretract":
tagHandlerU = new cycretract(targetBot, user, query, request, result, node);
break;
case "cycassert":
tagHandlerU = new cycassert(targetBot, user, query, request, result, node);
break;
case "cycterm":
tagHandlerU = new cycterm(targetBot, user, query, request, result, node);
break;
case "cycquery":
tagHandlerU = new cycquery(targetBot, user, query, request, result, node);
break;
case "cyccondition":
tagHandlerU = new cyccondition(targetBot, user, query, request, result, node);
break;
case "cycphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "cycparaphrase":
tagHandlerU = new cycphrase(targetBot, user, query, request, result, node);
break;
case "guard":
tagHandlerU = new guard(targetBot, user, query, request, result, node);
break;
case "guardstar":
tagHandlerU = new guardstar(targetBot, user, query, request, result, node);
break;
case "cycrandom":
tagHandlerU = new cycrandom(targetBot, user, query, request, result, node);
break;
case "tscore":
tagHandlerU = new tscore(targetBot, user, query, request, result, node);
break;
case "space":
tagHandlerU = new space(targetBot, user, query, request, result, node);
break;
case "markov":
tagHandlerU = new markov(targetBot, user, query, request, result, node);
break;
case "soundcode":
tagHandlerU = new soundcode(targetBot, user, query, request, result, node);
break;
// MSM
case "msm":
tagHandlerU = new msm(targetBot, user, query, request, result, node);
break;
case "processmsm":
tagHandlerU = new process_msm(targetBot, user, query, request, result, node);
break;
case "setstate":
tagHandlerU = new setstate(targetBot, user, query, request, result, node);
break;
case "state":
tagHandlerU = new state(targetBot, user, query, request, result, node);
break;
case "transition":
tagHandlerU = new transition(targetBot, user, query, request, result, node);
break;
case "setevidence":
tagHandlerU = new setevidence(targetBot, user, query, request, result, node);
break;
case "evidenceassoc":
tagHandlerU = new evidence_assoc(targetBot, user, query, request, result, node);
break;
case "evidencepattern":
tagHandlerU = new evidence_pattern(targetBot, user, query, request, result, node);
break;
case "evidencestate":
tagHandlerU = new evidencestate(targetBot, user, query, request, result, node);
break;
case "dependentmachine":
tagHandlerU = new dependentmachine(targetBot, user, query, request, result, node);
break;
case "responsetopic":
tagHandlerU = new response_topic(targetBot, user, query, request, result, node);
break;
case "push":
tagHandlerU = new push(targetBot, user, query, request, result, node);
break;
case "pop":
tagHandlerU = new pop(targetBot, user, query, request, result, node);
break;
case "peekstack":
tagHandlerU = new peekstack(targetBot, user, query, request, result, node);
break;
case "lex":
tagHandlerU = new lex(targetBot, user, query, request, result, node);
break;
case "lexset":
tagHandlerU = new lexset(targetBot, user, query, request, result, node);
break;
case "lexis":
tagHandlerU = new lexis(targetBot, user, query, request, result, node);
break;
case "dbpush":
tagHandlerU = new dbpush(targetBot, user, query, request, result, node);
break;
case "dbquery":
tagHandlerU = new dbquery(targetBot, user, query, request, result, node);
break;
case "dbupdate":
tagHandlerU = new dbupdate(targetBot, user, query, request, result, node);
break;
case "dbdelete":
tagHandlerU = new dbdelete(targetBot, user, query, request, result, node);
break;
case "dbload":
tagHandlerU = new dbload(targetBot, user, query, request, result, node);
break;
case "regex":
tagHandlerU = new regex(targetBot, user, query, request, result, node);
break;
case "bind": // <bind>#$isa</bind>
tagHandlerU = new bind(targetBot, user, query, request, result, node);
break;
case "#text":
if (!liText)
{
return(null);
}
return(new verbatum(node.Value, targetBot, user, query, request, result, node));
case "#comment":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
case "br":
return(new verbatum("\n", targetBot, user, query, request, result, node));
case "pre":
return(new verbatum(StaticXMLUtils.InnerXmlText(node), targetBot, user, query, request, result, node));
case "p":
return(new verbatum("\n\n", targetBot, user, query, request, result, node));
case "meta":
return(new verbatum(node.OuterXml, targetBot, user, query, request, result, node));
default:
break;
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (StaticAIMLUtils.IsHtmlTag(node.Name))
{
return(new recursiveVerbatum(node, targetBot, user, query, request, result, node, true));
}
if (tagHandlerU == null)
{
// "bot", "favorite", "fav"
foreach (KeyValuePair <string, string> prefix in new[]
{
new KeyValuePair <string, string>("get_", "get"),
new KeyValuePair <string, string>("set_", "set"),
new KeyValuePair <string, string>("bot_", "bot"),
new KeyValuePair <string, string>("favorite_", "bot"),
new KeyValuePair <string, string>("favorite", "bot"),
new KeyValuePair <string, string>("fav_", "bot"),
new KeyValuePair <string, string>("fav", "bot"),
new KeyValuePair <string, string>("get", "get"),
new KeyValuePair <string, string>("set", "set"),
new KeyValuePair <string, string>("bot", "bot"),
})
{
if (nodeNameLower.StartsWith(prefix.Key) && node.Name.Length > prefix.Key.Length)
{
string name = node.Name.Substring(prefix.Key.Length);
XmlNode pn = node.ParentNode;
LineInfoElementImpl newnode = StaticXMLUtils.CopyNode(prefix.Value, node, false);
XmlAttributeLineInfo atr = (XmlAttributeLineInfo)newnode.OwnerDocument.CreateAttribute("name");
atr.ReadOnly = false;
atr.Value = name;
newnode.Attributes.Append(atr);
if (node.Name.ToLower() != newnode.Name.ToLower())
{
writeToLog("AIMLLOADER: converted " + node.OuterXml + " -> " + newnode.OuterXml);
return(targetBot.GetTagHandler(newnode, query, request, result, user, liText));
}
writeToLog("AIMLLOADER: ! convert " + node.OuterXml + " -> " + newnode.OuterXml);
}
}
}
if (tagHandlerU != null)
{
return(tagHandlerU);
}
if (nodeNameLower == "name")
{
return(new bot(targetBot, user, query, request, result, node));
}
tagHandlerU = new lazyClosure(targetBot, user, query, request, result, node);
writeToLog("AIMLLOADER: lazyClosure: " + node.OuterXml);
return(tagHandlerU);
}
/// <summary>
/// Recursively evaluates the template nodes returned from the Proccessor
/// </summary>
/// <param name="node">the node to evaluate</param>
/// <param name="query">the query that produced targetBot node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="user">the user who originated the request</param>
/// <returns>the output Unifiable</returns>
public string processNode(XmlNode node, SubQuery query,
Request request, Result result, User user,
AIMLTagHandler parentHandlerU, bool protectChild, bool copyParent,
AIMLTagHandler nodeHandlerU, bool suspendLimits, out bool templateSucceeded)
{
Request originalSalientRequest = Request.GetOriginalSalientRequest(request);
bool osrExists = originalSalientRequest != null;
var wasSuspendRestrati = request == null || request.SuspendSearchLimits;
templateSucceeded = true;
if (request != null)
{
request.SuspendSearchLimits = suspendLimits;
}
Dictionary <Unifiable, Unifiable> sraiMark = null;
if (osrExists && ChatOptions.UseSraiLimitersBasedOnTextContent)
{
sraiMark = originalSalientRequest.CreateSRAIMark();
}
try
{
bool childSuccess;
string outputSentence = processNodeVV(node, query,
request, result, user, parentHandlerU,
protectChild, copyParent, nodeHandlerU, out childSuccess);
if (!childSuccess)
{
templateSucceeded = false;
}
if (Unifiable.IsNull(outputSentence))
{
//outputSentence = tagHandler.GetTemplateNodeInnerText();
templateSucceeded = false;
return(outputSentence);
}
if (!Unifiable.IsNullOrEmpty(outputSentence))
{
return(outputSentence);
}
if (StaticAIMLUtils.IsSilentTag(node) && !Unifiable.IsEMPTY(outputSentence))
{
return("");
}
if (nodeHandlerU.FinalResultValid)
{
return(nodeHandlerU.FinalResult);
}
return(outputSentence);
}
finally
{
if (osrExists && ChatOptions.UseSraiLimitersBasedOnTextContent)
{
originalSalientRequest.ResetSRAIResults(sraiMark);
}
if (request != null)
{
request.SuspendSearchLimits = wasSuspendRestrati;
}
}
}
/// <summary>
/// Recursively evaluates the template nodes returned from the bot
/// </summary>
/// <param name="node">the node to evaluate</param>
/// <param name="query">the query that produced this node</param>
/// <param name="request">the request from the user</param>
/// <param name="result">the result to be sent to the user</param>
/// <param name="user">the user who originated the request</param>
/// <returns>the output string</returns>
private string processNode(XmlNode node, SubQuery query, Request request, Result result, User user)
{
// check for timeout (to avoid infinite loops)
if (request.StartedOn.AddMilliseconds(request.bot.TimeOut) < DateTime.Now)
{
request.bot.writeToLog("WARNING! Request timeout. User: "******" raw input: \"" + request.rawInput + "\" processing template: \"" + query.Template + "\"");
request.hasTimedOut = true;
return(string.Empty);
}
StringBuilder newInnerText = new StringBuilder();
if (node.HasChildNodes)
{
// recursively check
foreach (XmlNode childNode in node.ChildNodes)
{
childNode.InnerText = this.processNode(childNode, query, request, result, user);
}
}
// process the node itself
AIMLTagHandler tagHandler = null;
switch (node.Name.ToLower())
{
case "bot":
tagHandler = new AIMLTagHandlers.bot(this, user, query, request, result, node);
break;
case "condition":
tagHandler = new AIMLTagHandlers.condition(this, user, query, request, result, node);
break;
case "date":
tagHandler = new AIMLTagHandlers.date(this, user, query, request, result, node);
break;
case "formal":
tagHandler = new AIMLTagHandlers.formal(this, user, query, request, result, node);
break;
case "gender":
tagHandler = new AIMLTagHandlers.gender(this, user, query, request, result, node);
break;
case "get":
tagHandler = new AIMLTagHandlers.get(this, user, query, request, result, node);
break;
case "gossip":
tagHandler = new AIMLTagHandlers.gossip(this, user, query, request, result, node);
break;
case "id":
tagHandler = new AIMLTagHandlers.id(this, user, query, request, result, node);
break;
case "input":
tagHandler = new AIMLTagHandlers.input(this, user, query, request, result, node);
break;
case "javascript":
tagHandler = new AIMLTagHandlers.javascript(this, user, query, request, result, node);
break;
case "learn":
tagHandler = new AIMLTagHandlers.learn(this, user, query, request, result, node);
break;
case "lowercase":
tagHandler = new AIMLTagHandlers.lowercase(this, user, query, request, result, node);
break;
case "person":
tagHandler = new AIMLTagHandlers.person(this, user, query, request, result, node);
break;
case "person2":
tagHandler = new AIMLTagHandlers.person2(this, user, query, request, result, node);
break;
case "random":
tagHandler = new AIMLTagHandlers.random(this, user, query, request, result, node);
break;
case "sentence":
tagHandler = new AIMLTagHandlers.sentence(this, user, query, request, result, node);
break;
case "set":
tagHandler = new AIMLTagHandlers.set(this, user, query, request, result, node);
break;
case "size":
tagHandler = new AIMLTagHandlers.size(this, user, query, request, result, node);
break;
case "sr":
tagHandler = new AIMLTagHandlers.sr(this, user, query, request, result, node);
break;
case "srai":
tagHandler = new AIMLTagHandlers.srai(this, user, query, request, result, node);
break;
case "star":
tagHandler = new AIMLTagHandlers.star(this, user, query, request, result, node);
break;
case "system":
tagHandler = new AIMLTagHandlers.system(this, user, query, request, result, node);
break;
case "that":
tagHandler = new AIMLTagHandlers.that(this, user, query, request, result, node);
break;
case "thatstar":
tagHandler = new AIMLTagHandlers.thatstar(this, user, query, request, result, node);
break;
case "think":
tagHandler = new AIMLTagHandlers.think(this, user, query, request, result, node);
break;
case "topicstar":
tagHandler = new AIMLTagHandlers.topicstar(this, user, query, request, result, node);
break;
case "uppercase":
tagHandler = new AIMLTagHandlers.uppercase(this, user, query, request, result, node);
break;
case "version":
tagHandler = new AIMLTagHandlers.version(this, user, query, request, result, node);
break;
default:
tagHandler = this.getBespokeTags(user, query, request, result, node);
break;
}
if (object.Equals(null, tagHandler))
{
return(node.InnerText);
}
else
{
return(tagHandler.Transform());
}
}
static public Unifiable GetSettingForType(string subject, SubQuery query, ISettingsDictionary dict, string name, out string realName, string gName, Unifiable defaultVal, out bool succeed, XmlNode node)
{
Request request = query.Request;
OutputDelegate writeToLog = request.writeToLog ?? TextPatternUtils.DEVNULL;
AltBot TargetBot = request.TargetBot;
ISettingsDictionary udict;
string dictName = AIMLTagHandler.GetNameOfDict(query, subject ?? dict.NameSpace, node, out udict);
// try to use a global blackboard predicate
User gUser = TargetBot.ExemplarUser;
defaultVal = StaticXMLUtils.GetAttribValue(node, "default,defaultValue", defaultVal);
gName = StaticXMLUtils.GetAttribValue(node, "global_name", gName);
string realName0;
var vv = ScriptManager.GetGroup(query.TargetBot.ObjectRequester, dictName, name);
{
if (vv != null)
{
if (vv.Count == 0)
{
succeed = true;
realName = name;
return("");
}
succeed = true;
realName = name;
foreach (var e in vv)
{
return(Unifiable.Create(e));
}
}
}
Unifiable resultGet = SettingsDictionaryReal.grabSettingDefaultDict(udict, name, out realName0);
if (ReferenceEquals(resultGet, null))
{
realName = null;
resultGet = Unifiable.NULL;
}
// if ((!String.IsNullOrEmpty(result)) && (!result.IsWildCard())) return result; // we have a local one
String realNameG;
// try to use a global blackboard predicate
Unifiable gResult = SettingsDictionaryReal.grabSettingDefaultDict(gUser.Predicates, gName, out realNameG);
if ((Unifiable.IsMissing(resultGet)) && (!Unifiable.IsMissing(gResult)))
{
// result=nothing, gResult=something => return gResult
writeToLog("SETTINGS OVERRIDE " + gResult);
succeed = true;
realName = realNameG;
// return gResult;
}
string sresultGet = resultGet.ToValue(query);
// if Unknown or empty
if (UseLuceneForGet && Unifiable.IsMissing(sresultGet))
{
Unifiable userName = udict.grabSetting("id");
if (Unifiable.IsNullOrEmpty(userName))
{
writeToLog("ERROR IsNullOrEmpty id in " + udict.NameSpace);
}
ITripleStore userbotLuceneIndexer = (ITripleStore)query.Request.TargetBot.TripleStore;
string resultLucene = userbotLuceneIndexer.queryTriple(userName, name, node);
if (!string.IsNullOrEmpty(resultLucene))
{
succeed = true;
realName = name;
return(resultLucene);
}
}
if (sresultGet != null)
{
if (sresultGet.ToUpper() == "UNKNOWN")
{
succeed = false;
realName = null;
return(sresultGet + " " + name);
}
else if (Unifiable.IsEMPTY(resultGet))
{
succeed = true;
realName = name;
return(resultGet);
}
else if (Unifiable.IsUnknown(resultGet))
{
succeed = false;
realName = name;
return(resultGet);
}
}
if (!String.IsNullOrEmpty(sresultGet))
{
succeed = true;
realName = realName0;
query.GetDictValue++;
if (!IsNullOrEmpty(gResult))
{
if (resultGet.IsWildCard)
{
realName = realNameG;
// result=*, gResult=something => return gResult
return(gResult);
}
// result=something, gResult=something => return result
return(resultGet);
}
else
{
// result=something, gResult=nothing => return result
return(resultGet);
}
}
if (defaultVal == null)
{
succeed = false;
realName = null;
return(defaultVal);
}
// default => return defaultVal
succeed = true;
realName = realName0;
return(ReturnSetSetting(udict, name, defaultVal));
//return defaultVal;
}
/// <summary>
/// Given a request containing user input, produces a result from the bot
/// </summary>
/// <param name="request">the request from the user</param>
/// <returns>the result to be output to the user</returns>
public Result Chat(Request request)
{
Result result = new Result(request.user, this, request);
bool IsAddResult = true;
if (this.isAcceptingUserInput)
{
// Normalize the input
AIMLLoader loader = new AIMLLoader(this);
AIMLbot.Normalize.SplitIntoSentences splitter = new AIMLbot.Normalize.SplitIntoSentences(this);
string[] rawSentences = splitter.Transform(request.rawInput);
foreach (string sentence in rawSentences)
{
result.InputSentences.Add(sentence);
string path = loader.generatePath(sentence, request.user.getLastBotOutput(), request.user.Topic, true);
result.NormalizedPaths.Add(path);
}
// grab the templates for the various sentences from the graphmaster
foreach (string path in result.NormalizedPaths)
{
Utils.SubQuery query = new SubQuery(path);
query.Template = this.Graphmaster.evaluate(path, query, request, MatchState.UserInput, new StringBuilder());
result.SubQueries.Add(query);
}
// process the templates into appropriate output
foreach (SubQuery query in result.SubQueries)
{
if (query.Template.Length > 0)
{
try
{
XmlNode templateNode = AIMLTagHandler.getNode(query.Template);
string outputSentence = this.processNode(templateNode, query, request, result, request.user);
if (outputSentence.Length > 0)
{
if (outputSentence.Contains("[notadd]"))
{
outputSentence = outputSentence.Replace("[notadd]", "");
IsAddResult = false;
}
result.OutputSentences.Add(outputSentence);
}
}
catch (Exception e)
{
if (this.WillCallHome)
{
this.phoneHome(e.Message, request);
}
this.writeToLog("WARNING! A problem was encountered when trying to process the input: " + request.rawInput + " with the template: \"" + query.Template + "\"");
}
}
}
}
else
{
result.OutputSentences.Add(this.NotAcceptingUserInputMessage);
}
// populate the Result object
result.Duration = DateTime.Now - request.StartedOn;
if (IsAddResult)
{
request.user.addResult(result);
}
return(result);
}
