/// <summary> /// /// </summary> /// <param name="filename"></param> /// <param name="trigger"></param> /// <param name="cmdValidator">Validates whether the given trigger may execute. Second parameter is line no.</param> public void ExecFile(string filename, CmdTrigger <C> trigger, Func <CmdTrigger <C>, int, bool> cmdValidator) { var line = 0; using (var reader = new StreamReader(filename)) { string cmd; while ((cmd = reader.ReadLine()) != null) { line++; cmd = cmd.Trim(); // '#' starts a comment if (!cmd.StartsWith("#") && cmd.Length > 0) { var text = new StringStream(cmd); trigger.Text = text; if (cmdValidator != null && !cmdValidator(trigger, line)) { continue; } if (!Execute(trigger)) { trigger.Reply("Could not execute Command from file \"{0}\" (line {1}): \"{2}\"", filename, line, cmd); } } } } }
/// <summary>Lets the given CmdTrigger trigger the given Command.</summary> /// <param name="trigger"></param> /// <param name="cmd"></param> /// <param name="silentFail">Will not reply if it failed due to target restrictions or privileges etc</param> /// <returns></returns> public virtual object Eval(CmdTrigger <C> trigger, BaseCommand <C> cmd, bool silentFail) { if (cmd.Enabled) { Command <C> rootCmd = cmd.RootCmd; if (!rootCmd.MayTrigger(trigger, cmd, silentFail) || !this.TriggerValidator(trigger, cmd, silentFail)) { return((object)false); } trigger.cmd = cmd; try { object obj = cmd.Eval(trigger); rootCmd.ExecutedNotify(trigger); return(obj); } catch (Exception ex) { rootCmd.FailNotify(trigger, ex); } return((object)true); } trigger.Reply("Command is disabled: " + (object)cmd); return((object)false); }
public void DisplayCmd(CmdTrigger <C> trigger, BaseCommand <C> cmd, bool ignoreRestrictions, bool detail) { trigger.Reply(string.Format("{0}{1}", cmd.CreateUsage(trigger), detail ? " (" + cmd.GetDescription(trigger) + ")" : "")); if (cmd.SubCommands.Count > 0) { trigger.Reply("All SubCommands:"); foreach (var subCmd in cmd.SubCommands) { if (MayDisplay(trigger, subCmd, ignoreRestrictions)) { DisplayCmd(trigger, subCmd, ignoreRestrictions, detail); } } } }
/// <summary> /// Lets the given CmdTrigger trigger the given Command. /// </summary> /// <param name="trigger"></param> /// <param name="cmd"></param> /// <param name="silentFail">Will not reply if it failed due to target restrictions or privileges etc</param> /// <returns></returns> public virtual object Eval(CmdTrigger <C> trigger, BaseCommand <C> cmd, bool silentFail) { if (cmd.Enabled) { var rootCmd = cmd.RootCmd; if (rootCmd.MayTrigger(trigger, cmd, silentFail) && TriggerValidator(trigger, cmd, silentFail)) { trigger.cmd = cmd; try { var obj = cmd.Eval(trigger); rootCmd.ExecutedNotify(trigger); return(obj); } catch (Exception e) { rootCmd.FailNotify(trigger, e); } return(true); } return(false); } trigger.Reply("Command is disabled: " + cmd); return(false); }
/// <summary>Lets the given CmdTrigger trigger the given Command.</summary> /// <param name="trigger"></param> /// <param name="cmd"></param> /// <param name="silentFail">Will not reply if it failed due to target restrictions or privileges etc</param> /// <returns></returns> public virtual bool Execute(CmdTrigger <C> trigger, BaseCommand <C> cmd, bool silentFail) { if (cmd.Enabled) { Command <C> rootCmd = cmd.RootCmd; if (!rootCmd.MayTrigger(trigger, cmd, silentFail) || !TriggerValidator(trigger, cmd, silentFail)) { return(false); } trigger.cmd = cmd; try { cmd.Process(trigger); rootCmd.ExecutedNotify(trigger); } catch (Exception ex) { rootCmd.FailNotify(trigger, ex); } return(true); } trigger.Reply("Command is disabled: " + cmd); return(false); }
/// <summary> /// Gives help /// TODO: Localization /// </summary> public void TriggerHelp(CmdTrigger <C> trigger, bool ignoreRestrictions) { if (trigger.Text.HasNext) { string remainder = trigger.Text.Remainder; List <BaseCommand <C> > commands = this.GetCommands(remainder); int count = commands.Count; foreach (BaseCommand <C> cmd in commands) { if (this.MayDisplay(trigger, cmd, ignoreRestrictions)) { this.DisplayCmd(trigger, cmd, ignoreRestrictions, true); } else { --count; } } if (count != 0) { return; } trigger.ReplyFormat("Did not find any Command that matches '{0}'.", (object)remainder); } else { int num = 0; foreach (Command <C> command in (IEnumerable <Command <C> >) this.Commands) { if (this.MayDisplay(trigger, (BaseCommand <C>)command, ignoreRestrictions)) { ++num; } } trigger.ReplyFormat("Use: ? <Alias> [<subalias> [<subalias> ...]] for help on a certain command."); trigger.Reply("All {0} available commands:", (object)num); foreach (Command <C> command in (IEnumerable <Command <C> >) this.Commands) { if (this.MayDisplay(trigger, (BaseCommand <C>)command, ignoreRestrictions)) { trigger.Reply(command.CreateUsage(trigger)); } } } }
public void DisplayCmd(CmdTrigger <C> trigger, BaseCommand <C> cmd, bool ignoreRestrictions, bool detail) { trigger.Reply(string.Format("{0}{1}", (object)cmd.CreateUsage(trigger), detail ? (object)(" (" + cmd.GetDescription(trigger) + ")") : (object)"")); if (cmd.SubCommands.Count <= 0) { return; } trigger.Reply("All SubCommands:"); foreach (BaseCommand <C> .SubCommand subCommand in cmd.SubCommands) { if (this.MayDisplay(trigger, (BaseCommand <C>)subCommand, ignoreRestrictions)) { this.DisplayCmd(trigger, (BaseCommand <C>)subCommand, ignoreRestrictions, detail); } } }
public override void Process(CmdTrigger <C> trigger) { if (!trigger.Text.HasNext) { trigger.Reply("No file was specified."); return; } var file = trigger.Text.NextWord(); if (!Path.IsPathRooted(file)) { file = Path.Combine(m_Mgr.ExecFileDir, file); } if (File.Exists(file)) { m_Mgr.ExecFile(file, trigger); } else { trigger.Reply("File to execute does not exist: " + file); } }
public override void Process(CmdTrigger <C> trigger) { if (!trigger.Text.HasNext) { trigger.Reply("No file was specified."); } else { string str = trigger.Text.NextWord(); if (!Path.IsPathRooted(str)) { str = Path.Combine(this.m_Mgr.ExecFileDir, str); } if (File.Exists(str)) { this.m_Mgr.ExecFile(str, trigger); } else { trigger.Reply("File to execute does not exist: " + str); } } }
protected void TriggerSubCommand(CmdTrigger <C> trigger) { string key = trigger.Text.NextWord(); BaseCommand <C> .SubCommand subCommand; if (this.m_subCommands.TryGetValue(key, out subCommand)) { if (!this.RootCmd.MayTrigger(trigger, (BaseCommand <C>)subCommand, false)) { return; } subCommand.Process(trigger); } else { trigger.Reply("SubCommand not found: " + key); trigger.Text.Skip(trigger.Text.Length); this.mgr.DisplayCmd(trigger, this, false, false); } }
protected void TriggerSubCommand(CmdTrigger <C> trigger) { var subAlias = trigger.Text.NextWord(); SubCommand subCmd; if (m_subCommands.TryGetValue(subAlias, out subCmd)) { if (RootCmd.MayTrigger(trigger, subCmd, false)) { subCmd.Process(trigger); } } else { trigger.Reply("SubCommand not found: " + subAlias); trigger.Text.Skip(trigger.Text.Length); mgr.DisplayCmd(trigger, this, false, false); } }
/// <summary> /// Lets the given CmdTrigger trigger the given Command. /// </summary> /// <param name="trigger"></param> /// <param name="cmd"></param> /// <param name="silentFail">Will not reply if it failed due to target restrictions or privileges etc</param> /// <returns></returns> public virtual bool Execute(CmdTrigger <C> trigger, BaseCommand <C> cmd, bool silentFail) { if (cmd.Enabled) { var rootCmd = cmd.RootCmd; if (!rootCmd.MayTrigger(trigger, cmd, silentFail)) { //trigger.Reply("Cannot trigger Command: " + rootCmd); } else if (TriggerValidator(trigger, cmd, silentFail)) { trigger.cmd = cmd; try { cmd.Process(trigger); // command callbacks rootCmd.ExecutedNotify(trigger); // TODO: Create a tree of expected responses? //string[] expectedReplies = cmd.ExpectedServResponses; //if (expectedReplies != null) { // trigger.expectsServResponse = true; // foreach (string reply in expectedReplies) { // AddWaitingTrigger(reply, trigger); // } //} } catch (Exception e) { rootCmd.FailNotify(trigger, e); } return(true); } return(false); } trigger.Reply("Command is disabled: " + cmd); return(false); }
/// <summary> /// /// </summary> /// <param name="filename"></param> /// <param name="trigger"></param> /// <param name="cmdValidator">Validates whether the given trigger may execute. Second parameter is line no.</param> public void ExecFile(string filename, CmdTrigger <C> trigger, Func <CmdTrigger <C>, int, bool> cmdValidator) { int num = 0; using (StreamReader streamReader = new StreamReader(filename)) { string str; while ((str = streamReader.ReadLine()) != null) { ++num; string s = str.Trim(); if (!s.StartsWith("#") && s.Length > 0) { StringStream stringStream = new StringStream(s); trigger.Text = stringStream; if ((cmdValidator == null || cmdValidator(trigger, num)) && !this.Execute(trigger)) { trigger.Reply("Could not execute Command from file \"{0}\" (line {1}): \"{2}\"", (object)filename, (object)num, (object)s); } } } } }
public override void Process(CmdTrigger <C> trigger) { StringStream text = trigger.Text; if (!text.HasNext) { trigger.Reply("Invalid arguments - " + this.CreateInfo(trigger)); } else { IExecutable executable1; if (text.ConsumeNext('-')) { if (!text.HasNext) { trigger.Reply("Invalid arguments - " + this.CreateInfo(trigger)); return; } if (char.ToLower(text.Remainder[0]) == 'l') { ++text.Position; string[] strArray = text.Remainder.Split(new char[1] { ' ' }, StringSplitOptions.RemoveEmptyEntries); ToolMgr toolMgr = ((CommandMgr <C> .CallCommand) this.RootCmd).ToolMgr; trigger.Reply("Callable functions ({0}):", (object)toolMgr.Executables.Count); for (int index = 0; index < toolMgr.ExecutableList.Count; ++index) { IExecutable executable2 = toolMgr.ExecutableList[index]; if (strArray.Length != 0) { bool flag = false; foreach (string str in strArray) { if (executable2.Name.IndexOf(str, StringComparison.InvariantCultureIgnoreCase) > -1) { flag = true; break; } } if (!flag) { continue; } } trigger.Reply(" {0}: {1}", (object)index, (object)executable2); } return; } uint num = text.NextUInt(uint.MaxValue); executable1 = (long)num >= (long)this.ToolMgr.ExecutableList.Count ? (IExecutable)null : this.ToolMgr.ExecutableList[(int)num]; } else { executable1 = this.ToolMgr.Get(text.NextWord()); } if (executable1 == null) { trigger.Reply("Could not find specified Executable."); } else { int length = executable1.ParameterTypes.Length; object[] objArray = new object[length]; object obj = (object)null; for (int index = 0; index < length; ++index) { Type parameterType = executable1.ParameterTypes[index]; StringParser.Parse(index == length - 1 ? text.Remainder : text.NextWord(), parameterType, ref obj); objArray[index] = obj; } executable1.Exec(objArray); } } }
public override void Reply(string text) { m_Trigger.Reply(text); }
public override void Process(CmdTrigger <C> trigger) { //var subAlias = trigger.Text.NextWord(); //SubCommand subCmd; //if (m_subCommands.TryGetValue(subAlias, out subCmd)) //{ // subCmd.Process(trigger); //} //else //{ var txt = trigger.Text; if (!txt.HasNext) { trigger.Reply("Invalid arguments - " + CreateInfo(trigger)); } else { IExecutable exec; if (txt.ConsumeNext('-')) { if (!txt.HasNext) { trigger.Reply("Invalid arguments - " + CreateInfo(trigger)); return; } var c = txt.Remainder[0]; if (Char.ToLower(c) == 'l') { txt.Position++; var matches = txt.Remainder.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); var toolMgr = ((CallCommand)RootCmd).ToolMgr; trigger.Reply("Callable functions ({0}):", toolMgr.Executables.Count); for (var i = 0; i < toolMgr.ExecutableList.Count; i++) { var executable = toolMgr.ExecutableList[i]; if (matches.Length != 0) { var found = false; foreach (var match in matches) { if (executable.Name.IndexOf(match, StringComparison.InvariantCultureIgnoreCase) > -1) { // match found = true; break; } } if (!found) { continue; } } trigger.Reply(" {0}: {1}", i, executable); } return; } // specified index var index = txt.NextUInt(uint.MaxValue); if (index < ToolMgr.ExecutableList.Count) { exec = ToolMgr.ExecutableList[(int)index]; } else { exec = null; } } else { // name var name = txt.NextWord(); exec = ToolMgr.Get(name); } if (exec == null) { trigger.Reply("Could not find specified Executable."); } else { var len = exec.ParameterTypes.Length; var args = new object[len]; object value = null; for (var i = 0; i < len; i++) { var paramType = exec.ParameterTypes[i]; var str = (i == len - 1) ? txt.Remainder : txt.NextWord(); // check for last argument StringParser.Parse(str, paramType, ref value); args[i] = value; } exec.Exec(args); } //base.Process(trigger); //trigger.Reply("SubCommand not found: " + subAlias); //trigger.Text.Skip(trigger.Text.Length); //mgr.DisplayCmd(trigger, this, false); } }