static void parse_cmd_str(string cmd_str)
{
/*
* These arrays are used instead of a Dictionary or List as the
* number of commands is incredibly small and thus a linear
* search of string comparisons will be instant. Besides, it's
* reasonably straight forward :)
*/
string[] cmds = new string[] {
"--install",
"--remove",
"--start",
"--stop"
};
CmdHandler[] cmd_hdlrs = new CmdHandler[] {
install_svc, remove_svc, start_svc, stop_svc
};
ServiceController svc_ctrl = get_svc_if_present();
bool[] req_inst_status = new bool[] {
false,
true,
true,
true
};
string[] err_msgs = new string[4] {
"The \"Menumate PosIntegration and Reservations\" service is already installed.",
"The \"Menumate PosIntegration and Reservations\" service is not installed.",
"The \"Menumate PosIntegration and Reservations\" service could not be started.",
"The \"Menumate PosIntegration and Reservations\" service could not be stopped."
};
for (int i = 0; i < cmds.Length; i++)
{
if (cmd_str == cmds[i])
{
if ((svc_ctrl != null) == req_inst_status[i])
{
cmd_hdlrs[i](svc_ctrl);
}
else
{
Console.WriteLine(err_msgs[i]);
}
return;
}
}
Console.WriteLine("Invalid command.");
display_usage();
}
/// <summary>
/// 异步运行，不用等待。需要考虑：如何清理进程。
/// </summary>
/// <param name="cmd">命令</param>
/// <returns></returns>
public IAsyncResult RunAsyn(string cmd)
{
CmdHandler handler = RunNoReturn;
IAsyncResult result = handler.BeginInvoke(cmd, AsyncProcessExited, null);
return(result);
}
public void CannotWithdrawFromBlockedAccount()
{
CmdHandler.Handle(new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
});
CmdHandler.Handle(new DepositCashCommand
{
AccountId = AccountId,
Amount = 1000m
});
var cmd = new WithdrawCashCommand()
{
AccountId = AccountId,
Amount = 10m
};
CmdHandler.Handle(cmd);
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("Account is blocked", msg.Exception.Message);
}
public void CannotWithdrawCashWithNonPositiveAmount(decimal amount)
{
CmdHandler.Handle(new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
});
CmdHandler.Handle(new DepositCashCommand
{
AccountId = AccountId,
Amount = 1000m
});
CmdHandler.Handle(new SetDailyWireTransferLimitCommand
{
AccountId = AccountId,
DailyWireTransferLimit = 1000m
});
var cmd = new WithdrawCashCommand()
{
AccountId = AccountId,
Amount = amount
};
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("Cannot withdraw a negative amount", msg.Exception.Message);
}
public void CanWithdrawCash()
{
CmdHandler.Handle(new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
});
CmdHandler.Handle(new DepositCashCommand
{
AccountId = AccountId,
Amount = 1000m
});
CmdHandler.Handle(new SetDailyWireTransferLimitCommand
{
AccountId = AccountId,
DailyWireTransferLimit = 1000m
});
var cmd = new WithdrawCashCommand()
{
AccountId = AccountId,
Amount = 100m
};
Assert.IsType <Success>(CmdHandler.Handle(cmd));
}
public void CannotExceedDailyWireTransferLimit()
{
CmdHandler.Handle(new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
});
CmdHandler.Handle(new DepositCashCommand
{
AccountId = AccountId,
Amount = 1000m
});
CmdHandler.Handle(new SetDailyWireTransferLimitCommand
{
AccountId = AccountId,
DailyWireTransferLimit = 100m
});
var cmd = new WithdrawCashCommand()
{
AccountId = AccountId,
Amount = 101m
};
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.StartsWith("Account is blocked, you only have", msg.Exception.Message);
}
public void Add <T>(CmdHandler <T> del) where T : ICommand, new()
{
T t = Activator.CreateInstance <T>();
t.Del = del;
mCmds.Add(t.GetType(), t);
}
public void CannotExceedOverDraftLimit()
{
CmdHandler.Handle(new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
});
CmdHandler.Handle(new SetDailyWireTransferLimitCommand
{
AccountId = AccountId,
DailyWireTransferLimit = 1000m
});
CmdHandler.Handle(new SetOverDraftLimitCommand
{
AccountId = AccountId,
OverDraftLimit = 100m
});
var cmd = new WithdrawCashCommand()
{
AccountId = AccountId,
Amount = 101m
};
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("Account is blocked, you exceeded your overdraft limit", msg.Exception.Message);
}
/// <summary>
/// 异步运行，不用等待。
/// </summary>
/// <param name="cmd"></param>
/// <returns></returns>
public void RunAsyn(string cmd)
{
CmdHandler handler = Run;
handler.BeginInvoke(cmd,
null,
null);
}
private static void OnGui(UnityModManager.ModEntry obj)
{
GUILayout.Label("Registered commands: ");
foreach (Command.Command cmd in CmdHandler.GetCommands())
{
GUILayout.Label(" " + cmd.Key());
}
}
public void CanCreateAccount()
{
var cmd = new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
};
Assert.IsType <Success>(CmdHandler.Handle(cmd));
}
public FFWorker BindHandler <T>(Pbmsg.ClientCmdDef cmd, PbHandler <T> method) where T : pb::IMessage, new()
{
CmdHandler ch = (Player player, string data) =>
{
T reqMsg = Util.String2Pb <T>(data);
method(player, reqMsg);
};
m_dictCmd2Func[(int)cmd] = ch;
return(this);
}
public void CannotWithdrawCashFromInvalidAccount()
{
var cmd = new WithdrawCashCommand()
{
AccountId = AccountId,
Amount = 200m
};
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("No account with this ID exists", msg.Exception.Message);
}
public void CannotCreateAccountWithWhiteSpaceName()
{
var cmd = new CreateAccountCommand()
{
AccountId = AccountId,
HolderName = " \t "
};
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("HolderName can't be empty", msg.Exception.Message);
}
public async Task PrefixCommand([Leftover] string prefix)
{
if (string.IsNullOrWhiteSpace(prefix))
{
return;
}
var oldPrefix = base.Prefix;
var newPrefix = CmdHandler.SetPrefix(ctx.Guild, prefix);
await ReplyConfirmLocalizedAsync("prefix_new", Format.Code(oldPrefix), Format.Code(newPrefix)).ConfigureAwait(false);
}
public new async Task Prefix([Remainder] string prefix)
{
if (string.IsNullOrWhiteSpace(prefix))
{
return;
}
var oldPrefix = base.Prefix;
var newPrefix = CmdHandler.SetPrefix(Context.Guild, prefix);
await ReplyConfirmLocalized("prefix_new", Format.Code(oldPrefix), Format.Code(newPrefix)).ConfigureAwait(false);
}
public void CannotDepositCheckIntoInvalidAccount()
{
var cmd = new DepositCheckCommand
{
AccountId = AccountId,
Amount = Convert.ToDecimal(100m)
};
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("No account with this ID exists", msg.Exception.Message);
}
/// <summary>
/// Register plothandlers, which want to receive plot commands for a plot
/// </summary>
/// <param name="plotTarget">plot name to target</param>
/// <param name="handler">the handling delegate of the received command</param>
public void RegisterCmdHandler(string plotTarget, CmdHandler handler)
{
Debug.Log("Registering handler for target: " + plotTarget);
if (!cmdHandlers.ContainsKey(plotTarget))
{
cmdHandlers.Add(plotTarget, new CmdHandler(handler));
}
else
{
cmdHandlers[plotTarget] += handler;
}
}
public void CannotSetLimitOnInvalidAccount()
{
var cmd = new SetOverDraftLimitCommand
{
AccountId = AccountId,
OverDraftLimit = 100m
};
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("No account with this ID exists", msg.Exception.Message);
}
/// <summary>
/// AddItemToCommandMap
/// </summary>
/// <param name="key">int</param>
/// <param name="command">CmdHandler</param>
public static void AddItemToCommandMap(int key, CmdHandler command)
{
if (null == CmdMap)
{
GlobalDefinition.LoggerWrapper.LogTraceInfo("CmdMap is null");
return;
}
if (!CmdMap.ContainsKey(key))
{
CmdMap.Add(key, command);
}
}
public void CannotCreateAccountWithSameId()
{
var cmd = new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
};
CmdHandler.Handle(cmd);
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("An account with this ID already exists", msg.Exception.Message);
}
public void RegCmd(string cmd, CmdHandler handler)
{
if (!string.IsNullOrEmpty(cmd) && handler != null)
{
if (_onCmdExecute.ContainsKey(cmd))
{
_onCmdExecute[cmd] = handler;
}
else
{
_onCmdExecute.Add(cmd, handler);
}
}
}
public async Task DefPrefix([Remainder] string prefix)
{
if (string.IsNullOrWhiteSpace(prefix))
{
await ReplyConfirmLocalized("defprefix_current", CmdHandler.DefaultPrefix).ConfigureAwait(false);
return;
}
var oldPrefix = CmdHandler.DefaultPrefix;
var newPrefix = CmdHandler.SetDefaultPrefix(prefix);
await ReplyConfirmLocalized("defprefix_new", Format.Code(oldPrefix), Format.Code(newPrefix)).ConfigureAwait(false);
}
public void CanSetOverDraftLimit(decimal limit)
{
CmdHandler.Handle(new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
});
var cmd = new SetOverDraftLimitCommand
{
AccountId = AccountId,
OverDraftLimit = limit
};
Assert.IsType <Success>(CmdHandler.Handle(cmd));
}
public void CanDepositCheck(decimal amount)
{
CmdHandler.Handle(new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
});
var cmd = new DepositCheckCommand
{
AccountId = AccountId,
Amount = amount
};
Assert.IsType <Success>(CmdHandler.Handle(cmd));
}
public IEnumerator HandleCommand()
{
while (true)
{
Command command = CommandDispatcher.GetCommand();
if (command == null)
{
yield return(null);
}
else
{
Logger.v("Find command : " + command.cmd + " value :" + command.recvObj);
try
{
CmdHandler handler = null;
if (handlers.TryGetValue(command.cmd, out handler))
{
long beg = DateTime.Now.Ticks / 10000;
handler(command);
StringBuilder sb = new StringBuilder();
sb.Append("[");
sb.Append(command.socket);
sb.Append("] Cmd: ");
sb.Append(command.cmd);
sb.Append(" costs: ");
sb.Append(DateTime.Now.Ticks / 10000 - beg);
sb.Append("ms");
Debug.Log(sb.ToString());
sdkUseTime += (DateTime.Now.Ticks / 10000 - beg) / 1000;
}
else
{
//没法找到
command.status = ResponseStatus.NO_SUCH_CMD;
CommandDispatcher.SendCommand(command);
}
}
catch (System.Exception ex)
{
Logger.d("Handle Command expection =>" + ex.Message + " \n" + ex.StackTrace);
command.status = ResponseStatus.UN_KNOW_ERROR;
CommandDispatcher.SendCommand(command);
}
}
yield return(null);
}
}
public void RegisterCmdHandler(string cmd, CmdHandler handler)
{
if (cmdHandlers.ContainsKey(cmd))
{
Debug.LogError("cmd: " + cmd + " has registered");
return;
}
if (handler != null)
{
cmdHandlers[cmd] = handler;
}
else
{
Debug.LogError("handler function is null");
}
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
int argCount = arguments.Count;
//Ignore with the incorrect number of arguments
if (argCount != 2)
{
QueueMessage(UsageMessage);
return;
}
string commandName = arguments[0].ToLowerInvariant();
string enabledStr = arguments[1];
bool cmdEnabled = false;
using (BotDBContext context = DatabaseManager.OpenContext())
{
//Find the command
CommandData cmdData = context.Commands.FirstOrDefault(c => c.Name == commandName);
if (cmdData == null)
{
QueueMessage($"Cannot find a command named \"{commandName}\".");
return;
}
if (bool.TryParse(enabledStr, out cmdEnabled) == false)
{
QueueMessage("Incorrect command enabled state specified.");
return;
}
cmdData.Enabled = (cmdEnabled == true) ? 1 : 0;
context.SaveChanges();
}
BaseCommand baseCmd = CmdHandler.GetCommand(commandName);
baseCmd.Enabled = cmdEnabled;
QueueMessage($"Successfully set the enabled state of command \"{commandName}\" to {cmdEnabled}!");
}
public void CannotDepositCheckWithNonPositiveAmount(decimal amount)
{
CmdHandler.Handle(new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
});
var cmd = new DepositCheckCommand
{
AccountId = AccountId,
Amount = amount
};
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("Cannot deposit a negative amount", msg.Exception.Message);
}
public void CannotSetNegativeLimit(decimal limit)
{
CmdHandler.Handle(new CreateAccountCommand
{
AccountId = AccountId,
HolderName = "John Doe"
});
var cmd = new SetOverDraftLimitCommand
{
AccountId = AccountId,
OverDraftLimit = limit
};
dynamic msg = CmdHandler.Handle(cmd);
Assert.IsType <Fail>(msg);
Assert.Equal("Overdraft limit cannot be negative", msg.Exception.Message);
}
