public object[] getArgs(MethodInfo info, CmdParam param, CmdAttribute attr)
{
var fparam = info.GetParameters();
object[] args = new object[fparam.Length];
if (attr == null)
{
Debug.Fail("Must apply a [MsgAttribute] to method");
return(args);
}
// 沒有参数
if (fparam.Length == 0)
{
return(args);
}
for (int i = 0; i < fparam.Length; i++)
{
var f = fparam[i];
var name = fparam[i].Name;
// 单个参数
if (f.ParameterType == typeof(string))
{
args[i] = param[name];
}
// 多个参数
else if (f.ParameterType == typeof(List <string>))
{
args[i] = param[name, true];
}
else
{
System.Console.WriteLine(string.Format("Error parameter type : {0} {1}", f.Name, f.ParameterType));
}
var mpa = f.GetCustomAttribute <CmdParamAttribute> ();
// 设置了属性
if (mpa != null)
{
if (args[i] == null)
{
if (mpa.require)
{
throw new ArgumentException("Require parameter : {0}!".format(name));
} // 需要的参数
else if (mpa.defaultValue != null)
{
args[i] = mpa.defaultValue;
} // 默认值
else if (mpa.isswitch)
{
args[i] = "true";
} // 开关
}
}
}
return(args);
}
public CmdParam parseArgs(string[] array)
{
CmdParam param = new CmdParam();
if (array == null)
{
return(param);
}
for (int i = 0; i < array.Length; i++)
{
var raw = array[i].Trim();
if (!raw.valid() || raw[0] == '#')
{
continue;
}
string[] one = raw.Split('=');
if (one.Length == 1)
{
param[one[0]] = null;
}
else if (one.Length == 2)
{
param[one[0]] = one[1];
}
}
return(param);
}
//public static async Task<dynamic> Post(CmdParam cmdParam,int? basePort ,int? targetPort)
//{
// basePort = basePort ?? DefaultApiPort.ChromePort;
// targetPort = targetPort ?? DefaultApiPort.ArmPort;
// string baseAddress = string.Format("http://localhost:{0}/", basePort);
// string targetAddress = string.Format("http://localhost:{0}/", targetPort);
// using (var client = new HttpClient())
// {
// client.BaseAddress = new Uri(baseAddress);
// //var data = JObject.FromObject(new
// //{
// // name = "some value",
// // version = new { type = "some value", ver = 2 }
// //});
// var data = JObject.FromObject(cmdParam);
// var response = client.PostAsync(targetAddress,
// new StringContent(JsonConvert.SerializeObject(data),
// Encoding.UTF8, "application/json")).Result;
// response.EnsureSuccessStatusCode();
// var responseContent = await response.Content.ReadAsStringAsync();
// dynamic json = JsonConvert.DeserializeObject(responseContent);
// dynamic r = json.result;
// // result = r.someproperty.ToString().Equals("resultdata");
// return r;
// }
//}
public static async Task <dynamic> ChromePostToRightArm(CmdParam cmdParam, string controller = "right")
{
//int basePort = DefaultApiPort.ChromePort;
int targetPort = DefaultApiPort.ArmPort;
//string baseAddress = string.Format("http://localhost:{0}/", basePort);
string targetAddress = string.Format("http://localhost:{0}/arm/{1}", targetPort, controller);
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(targetAddress);
try
{
var stringContent = new StringContent(JsonConvert.SerializeObject(cmdParam), Encoding.UTF8, "application/json");
var response = await client.PostAsync("", stringContent);
response.EnsureSuccessStatusCode();
var responseContent = await response.Content.ReadAsStringAsync();
dynamic json = JsonConvert.DeserializeObject(responseContent);
dynamic r = json.result;
// result = r.someproperty.ToString().Equals("resultdata");
return(r);
}
catch (Exception err)
{
LogApplication.Agent.LogError(err);
}
return(null);
}
}
public static void Retry()
{
ConfigManager config = new ConfigManager();
var screenshotOnFail = config.GetValue("ScreenshotOnFail");
if (File.Exists(screenshotOnFail))
{
if (RetryCount < 3)
{
RetryCount += 1;
File.Delete(screenshotOnFail);
BotHttpClient.Log("RETRY FAILED RUN... Retry count is " + RetryCount.ToString(), true);
GlobalDef.CurrentDesigner.HandleCmd(MyCmd);
return;
}
}
//show result to azure event...
BotHttpClient.Log("Done WF Run... Retry count is " + RetryCount.ToString(), false);
RetryCount = 0;
MyCmd = null;
//xTODO.. create azure event here...
}
static int Main(string[] args)
{
var cmdParam = new CmdParam(args);
if (cmdParam.ContainsUasgeParam())
{
Console.WriteLine(CmdMessage.GetUsage());
}
else if (cmdParam.IsError())
{
Console.WriteLine(CmdMessage.GetUsageErrorPrompt());
return(Error);
}
else
{
ShowCurrentDirectory();
var cmdEntry = new CmdEntry(cmdParam);
foreach (var line in cmdEntry.GetExecuteResult())
{
Console.WriteLine(line);
}
}
return(Success);
}
// If your activity returns a value, derive from CodeActivity<TResult>
// and return the value from the Execute method.
protected override void Execute(NativeActivityContext context)
{
// Obtain the runtime value of the Text input argument
try
{
#region --------------------TRY CONTENT----------------------
//Global.IsScanBusy = true;
Global.ProcessStatus = ProcessStatus.Scanning.ToString();
BaiRocService azureSvc = new BaiRocService();
azureSvc.OnReadDone += AzureSvc_OnReadDone;
// Obtain the runtime value of the Text input argument
CmdParam p = context.GetValue(this.Param);
ScanImageCmdParam payload = (ScanImageCmdParam)p.Payload;
var fname = payload.FileFullPath;
azureSvc.ReadImage(fname);
//context.SetValue(this.Result, azureSvc.RawList);
#endregion
}
catch (Exception err)
{
Global.LogError("ScanImage---> " + err.Message);
Global.ProcessStatus = ProcessStatus.Ready.ToString();
}
}
// If your activity returns a value, derive from CodeActivity<TResult>
// and return the value from the Execute method.
protected override void Execute(CodeActivityContext context)
{
// Obtain the runtime value of the Text input argument
try
{
#region --------------------TRY CONTENT----------------------
CmdParam p = context.GetValue(this.Param);
TestSampleCmdParam payload = (TestSampleCmdParam)p.Payload;
//DoTest
//Global.MainWindow.SafeInvoke(f => f.DoTestSample(payload.SampleMessage));
Global.MainWindow.InvokeOnUiThread(
() => Global.MainWindow.DoTestSample(payload.SampleMessage));
#endregion
}
catch (Exception err)
{
Global.LogError(err.Message);
}
finally
{
// Global.MainWindow.SafeInvoke(c => c.HideBusy());
}
}
public void should_return_true_when_args_contains_the_usage_parameter()
{
var cmdParam1 = new CmdParam(new[] { "/f", "/?" });
var cmdParam2 = new CmdParam(new[] { "/?" });
Assert.AreEqual(true, cmdParam1.ContainsUasgeParam());
Assert.AreEqual(true, cmdParam2.ContainsUasgeParam());
}
public void should_return_false_when_first_parameter_is_not_width_list_show_parameter()
{
var cmdParam1 = new CmdParam(new[] { "/f" });
var cmdParam2 = new CmdParam(new string[] { });
Assert.AreEqual(false, cmdParam1.IsWidthListShowParam());
Assert.AreEqual(false, cmdParam2.IsWidthListShowParam());
}
public void should_return_true_when_args_is_error()
{
var cmdParam1 = new CmdParam(new[] { "f", });
var cmdParam2 = new CmdParam(new[] { "/" });
Assert.AreEqual(true, cmdParam1.IsError());
Assert.AreEqual(true, cmdParam2.IsError());
}
public void should_return_false_when_args_not_contains_the_usage_parameter()
{
var cmdParam1 = new CmdParam(new[] { "6", " ", "/x" });
var cmdParam2 = new CmdParam(new string[] { });
Assert.AreEqual(false, cmdParam1.ContainsUasgeParam());
Assert.AreEqual(false, cmdParam2.ContainsUasgeParam());
}
public void should_return_true_when_last_parameter_is_the_reserved_parameter()
{
var cmdParam1 = new CmdParam(new[] { "6", " ", "/x" });
var cmdParam2 = new CmdParam(new[] { "6", "/x" });
var cmdParam3 = new CmdParam(new[] { "/x" });
Assert.AreEqual(true, cmdParam1.IsCompatibleModeParam());
Assert.AreEqual(true, cmdParam2.IsCompatibleModeParam());
Assert.AreEqual(true, cmdParam3.IsCompatibleModeParam());
}
public void should_return_false_when_last_parameter_is_not_the_reserved_parameter()
{
var cmdParam1 = new CmdParam(new[] { "6", "/x", " " });
var cmdParam2 = new CmdParam(new[] { "6" });
var cmdParam3 = new CmdParam(new string[] { });
Assert.AreEqual(false, cmdParam1.IsCompatibleModeParam());
Assert.AreEqual(false, cmdParam2.IsCompatibleModeParam());
Assert.AreEqual(false, cmdParam3.IsCompatibleModeParam());
}
public void should_return_true_when_first_parameter_is_width_list_show_parameter()
{
var cmdParam1 = new CmdParam(new[] { "/w" });
var cmdParam2 = new CmdParam(new [] { "/W" });
var cmdParam3 = new CmdParam(new [] { "/w", "/f" });
Assert.AreEqual(true, cmdParam1.IsWidthListShowParam());
Assert.AreEqual(true, cmdParam2.IsWidthListShowParam());
Assert.AreEqual(true, cmdParam3.IsWidthListShowParam());
}
public static void ReadEventCmdParam(CmdParam state)
{
if (state == null)
{
return;
}
//var cmdParam = state as ChessCommandParam;//CmdParam;
//Resume the Activity that set this bookmark(ReadString).
Global.ThisWF.ResumeBookmark("CmdParamBookMark", state);
}
public void should_return_matching_parameter_string_when_given_parameter_is_correct()
{
var cmdParam1 = new CmdParam(new[] { "/d" });
var cmdParam2 = new CmdParam(new[] { "/f" });
var cmdParam3 = new CmdParam(new[] { "/w" });
var cmdParam4 = new CmdParam(new string[] { });
Assert.AreEqual(CmdMessage.OnlyShowFolderParam, cmdParam1.GetCmdRunParam());
Assert.AreEqual(CmdMessage.OnlyShowFileParam, cmdParam2.GetCmdRunParam());
Assert.AreEqual(CmdMessage.WidthListShowParam, cmdParam3.GetCmdRunParam());
Assert.AreEqual(CmdMessage.ShowFileAndFolderParam, cmdParam4.GetCmdRunParam());
}
public void should_return_false_when_args_is_not_error()
{
var cmdParam1 = new CmdParam(new[] { "/f" });
var cmdParam2 = new CmdParam(new[] { "/d" });
var cmdParam3 = new CmdParam(new[] { "/w" });
var cmdParam4 = new CmdParam(new[] { "/?" });
var cmdParam5 = new CmdParam(new string[] { });
Assert.AreEqual(false, cmdParam1.IsError());
Assert.AreEqual(false, cmdParam2.IsError());
Assert.AreEqual(false, cmdParam3.IsError());
Assert.AreEqual(false, cmdParam4.IsError());
Assert.AreEqual(false, cmdParam5.IsError());
}
public void should_return_double_characters_wide_table_border_when_turn_on_compatible_mode()
{
var lines = new List <string>()
{
"1 2成",
"1 2 3",
};
var cmdParam = new CmdParam(new[] { "3", " ", "/x" });
var cmdEntry = new CmdEntry(lines, cmdParam);
var table = string.Join(Environment.NewLine, cmdEntry.GetExecuteResult());
Assert.AreEqual("┌─────┐" + Environment.NewLine +
"│1 2成 │" + Environment.NewLine +
"├─┬─┬─┤" + Environment.NewLine +
"│1 │2 │3 │" + Environment.NewLine +
"└─┴─┴─┘", table);
}
/// <summary>
///
/// </summary>
/// <param name="args"></param>
private void ParseCommandLine(string[] args)
{
ParseState state = ParseState.Start;
CmdParam cp = null;
foreach (var a in args)
{
string cmd = a;
while ((cmd.Length > 0) && (cmd[0] == '-'))
{
cmd = cmd.Remove(0, 1);
}
switch (state)
{
case ParseState.Start:
if (cmds.ContainsKey(cmd))
{
ArgRule rule = cmds[cmd];
cp = new CmdParam(rule.Key);
cmdParams.Add(cp);
if (rule.HasParam)
{
state = ParseState.StringArg;
}
}
else
{
cp = new CmdParam("", a);
cmdParams.Add(cp);
}
break;
case ParseState.StringArg:
cp.Value = a;
state = ParseState.Start;
break;
}
}
}
public static int Main(string[] args)
{
var cmdParam = new CmdParam(args);
if (cmdParam.ContainsUasgeParam())
{
Console.WriteLine(CmdMessage.GetUsage());
}
else if (Console.IsInputRedirected)
{
var cmdEntry = new CmdEntry(GetRedirectedInput(), cmdParam);
foreach (var line in cmdEntry.GetExecuteResult())
{
Console.WriteLine(line);
}
}
else
{
Console.WriteLine(CmdMessage.GetUsageErrorPrompt());
return(Error);
}
return(Success);
}
public CmdParam parseArgs(string str, int startIndex = 0)
{
JsonRequest req = null;
try {
req = JsonConvert.DeserializeObject <JsonRequest> (str);
if (req == null)
{
return(null);
}
}
catch (Exception ex) {
throw new JsonRpcException(-32700, "Parse error", ex);
}
CmdParam param = new CmdParam();
param.data = req;
if (req.Params is string)
{
param[0] = req.Params as string;
}
return(param);
}
public CmdParam parseArgs(string[] array)
{
CmdParam param = new CmdParam();
int @default = 0;
for (int i = 0; i < array.Length; i++)
{
if (string.IsNullOrEmpty(array[i]))
{
continue;
}
// 不是参数
if (!array[i].StartsWith(longPre) && !array[i].StartsWith(shortPre))
{
param[@default++] = array[i];
}
// 是否是最后一个
else if (i == array.Length - 1)
{
// 长参数
if (array[i].StartsWith(longPre))
{
param[array[i].Replace(longPre, "")] = null;
}
// 短参数
else
{
param[array[i].Replace(shortPre, "")] = null;
}
}
else
{
// 下一个不是参数
if (!array[i + 1].StartsWith(longPre) && !array[i + 1].StartsWith(shortPre))
{
// 长参数
if (array[i].StartsWith(longPre))
{
param[array[i].Replace(longPre, "")] = array[i + 1];
}
// 短参数
else
{
param[array[i].Replace(shortPre, "")] = array[i + 1];
}
i++;
}
else
{
// 长参数
if (array[i].StartsWith(longPre))
{
param[array[i].Replace(longPre, "")] = null;
}
// 短参数
else
{
param[array[i].Replace(shortPre, "")] = null;
}
}
}
}
#if DEBUG
System.Console.WriteLine(param.ToString());
#endif
return(param);
}
public object[] getArgs(MethodInfo info, CmdParam param, CmdAttribute attr)
{
var fparam = info.GetParameters();
object[] args = new object[fparam.Length];
if (attr == null)
{
Debug.Fail("Must apply a [MsgAttribute] to method");
return(args);
}
// 沒有参数
if (fparam.Length == 0)
{
return(args);
}
// 多个参数
for (int i = 0; i < fparam.Length; i++)
{
var f = fparam[i];
var l = f.Name.ToLower(); // 长名字
var s = !attr.disableShort ? l[0].ToString() : null; // 短名字
var d = attr.collectDefault == null && s != null ? i : -1;
// 单个参数
if (f.ParameterType == typeof(string))
{
args[i] = param[l, s, d];
}
// 多个参数
else if (f.ParameterType == typeof(List <string>))
{
args[i] = param[l, s, d, true];
}
else
{
System.Console.WriteLine(string.Format("Error parameter type : {0} {1}", f.Name, f.ParameterType));
}
// 收集默认参数
if (attr.collectDefault == f.Name.ToLower())
{
if (f.ParameterType == typeof(List <string>))
{
var all = param.getAllDefault();
if (args[i] != null)
{
all.AddRange((List <string>)args[i]);
}
args[i] = all;
}
else
{
System.Console.WriteLine(string.Format("Parameter type must be List<string>"));
}
}
var mpa = f.GetCustomAttribute <CmdParamAttribute> ();
// 设置了属性
if (mpa != null)
{
if (args[i] == null)
{
if (mpa.require)
{
throw new ArgumentException("Require parameter : {0}!".format(l));
} // 需要的参数
else if (mpa.defaultValue != null)
{
args[i] = mpa.defaultValue;
} // 默认值
else if (mpa.isswitch)
{
args[i] = "true";
} // 开关
}
}
}
return(args);
}
public void should_return_given_separator_when_second_parameter_given_the_separator()
{
var cmdParam = new CmdParam(new[] { "6", "-", "/x" });
Assert.AreEqual("-", cmdParam.GetSeparatorParam());
}
public Task <CmdParam> DoCmd(CmdParam command)
{
throw new NotImplementedException();
}
public void should_return_0_when_args_is_empty()
{
var cmdParam = new CmdParam(new string[] { });
Assert.AreEqual(0, cmdParam.GetColumnParam());
}
public void should_return_0_when_first_parameter_is_invalid_numeric_string()
{
var cmdParam = new CmdParam(new[] { "/x" });
Assert.AreEqual(0, cmdParam.GetColumnParam());
}
public void should_return_given_number_when_first_parameter_is_valid_numeric_string()
{
var cmdParam = new CmdParam(new[] { "6", "-", "/x" });
Assert.AreEqual(6, cmdParam.GetColumnParam());
}
public void should_return_a_blank_space_when_args_is_empty()
{
var cmdParam = new CmdParam(new string[] { });
Assert.AreEqual(" ", cmdParam.GetSeparatorParam());
}
public void should_return_a_blank_space_when_second_parameter_is_not_exist()
{
var cmdParam = new CmdParam(new[] { "6" });
Assert.AreEqual(" ", cmdParam.GetSeparatorParam());
}
