/// <summary> /// execute indicator /// </summary> /// <param name="argument"></param> /// <returns></returns> public bool?Indicate(ArgumentProvider argument) { var actual = argument.Format(Actual); var expected = Expected.Select(x => argument.Format(x)); var match = expected.Any(x => string.Equals(actual, x, StringComparison.CurrentCultureIgnoreCase)); if (Not) { match = !match; } if (match) { if (IsSuccess) { return(true); } else if (IsFail) { return(false); } else { return(null); } } else { return(null); } }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <PeekListActionSetting>(actionSetting); var listJson = argument.Format(setting.Source); try { var list = JsonHelper.GetArray(listJson, setting.Source); var results = new List <JToken>(); foreach (var listItem in list) { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("sourceItem"); tmpArgument.PutPrivate("sourceItem", listItem.ToString()); if (setting?.Where?.Any() != true || setting?.Where?.Any(x => x.Indicate(tmpArgument) ?? false) == true) { string targetValue = tmpArgument.Format(setting.Target, true); if (setting.AsString) { results.Add(targetValue); } else { var valueObj = JsonHelper.TryGetObject(targetValue, setting.Target); if (valueObj == null) { results.Add(targetValue); } else { targetValue = JsonConvert.SerializeObject(valueObj); results.Add(valueObj); } } } } var resultStr = JsonConvert.SerializeObject(results); return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", resultStr } }, Data = resultStr })); } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message, Output = new Dictionary <string, string> { }, Data = string.Empty })); } }
public void TestEventBody() { WorkingArguments workingArguments = new WorkingArguments(); ArgumentProvider argProvider = new ArgumentProvider(workingArguments); argProvider.PutPrivate("lastCheckResult", "{\"data\":null,\"success\":false,\"code\":null,\"message\":\"Cannot get any products by style number: [20200122].\",\"exception\":null}"); argProvider.PutPrivate("now", "2019/12/11T09:00:00.000Z"); argProvider.PutPrivate("input.merchantOrderId", "merchantOrderId"); var targetStr = "{\"message\":\"{\\\"name\\\":\\\"InvalidOrder\\\",\\\"time\\\":\\\"2019/12/11T09:00:00.000Z\\\",\\\"data\\\":{\\\"orderId\\\":\\\"merchantOrderId\\\",\\\"messages\\\":{\\\"data\\\":null,\\\"success\\\":false,\\\"code\\\":null,\\\"message\\\":\\\"Cannot get any products by style number: [20200122].\\\",\\\"exception\\\":null}}}\"}"; var setProcessor = new SetValueProcessor(); var setSetting1 = new SetValueActionSetting { Set = new Dictionary <string, string> { { "orderId", "{{input.merchantOrderId}}" }, { "messages", "{{lastCheckResult}}" } } }; var res1 = setProcessor.Execute(JsonConvert.SerializeObject(setSetting1), argProvider).Result; argProvider.PutPrivate("event_msg_data", res1.Data); var setSetting2 = new SetValueActionSetting { Set = new Dictionary <string, string> { { "name", "InvalidOrder" }, { "time", "{{now}}" }, { "data", "{{event_msg_data}}" } } }; var res2 = setProcessor.Execute(JsonConvert.SerializeObject(setSetting2), argProvider).Result; argProvider.PutPrivate("event_msg", res2.Data); var setSetting3 = new SetValueActionSetting { Set = new Dictionary <string, string> { { "message", "{{event_msg}}" } }, AsString = true }; var res3 = setProcessor.Execute(JsonConvert.SerializeObject(setSetting3), argProvider).Result; argProvider.PutPrivate("event_body", res3.Data); var resultStr = argProvider.Format("{{event_body}}"); Assert.AreEqual(targetStr, resultStr); }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <MapListActionSetting>(actionSetting); var listJson = argument.Format(setting.Source); try { var list = JsonHelper.GetArray(listJson, setting.Source); var results = new List <Dictionary <string, string> >(); foreach (var listItem in list) { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("mapItem"); tmpArgument.PutPrivate("mapItem", listItem.ToString()); if (setting?.Where?.Any() != true || setting?.Where?.Any(x => x.Indicate(tmpArgument) ?? false) == true) { Dictionary <string, string> result = new Dictionary <string, string>(); foreach (var rule in setting.Output) { result.Add(rule.Key, tmpArgument.Format(rule.Value, true)); } results.Add(result); } } var resultStr = JsonConvert.SerializeObject(results); return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", resultStr } }, Data = resultStr })); } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message, Output = new Dictionary <string, string> { }, Data = string.Empty })); } }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <BooleanProcessActionSetting>(actionSetting); try { bool arg = bool.Parse(argument.Format(setting.Arg)); bool res = false; switch (setting.Action.ToLower()) { case "not": case "!": res = !arg; break; default: return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = $"Action ({setting.Action}) is not known" })); } return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", res.ToString() } }, Data = res.ToString() })); } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message })); } }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <GroupListActionSetting>(actionSetting); var listJson = argument.Format(setting.Source); try { var list = JsonHelper.GetArray(listJson, setting.Source); var result = new List <Dictionary <string, string> >(); Dictionary <string, JArray> groupData = new Dictionary <string, JArray>(); foreach (var listItem in list) { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("loopItem"); tmpArgument.PutPrivate("loopItem", listItem.ToString()); var key = tmpArgument.Format(setting.Key, true); if (groupData.ContainsKey(key)) { groupData[key].Add(listItem); } else { groupData[key] = new JArray { listItem }; } } foreach (var kvp in groupData) { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("groupKey"); tmpArgument.ClearKey("groupItems"); tmpArgument.PutPrivate("groupKey", kvp.Key.ToString()); tmpArgument.PutPrivate("groupItems", kvp.Value.ToString()); Dictionary <string, string> results = new Dictionary <string, string>(); foreach (var rule in setting.Output) { results.Add(rule.Key, tmpArgument.Format(rule.Value, true)); } result.Add(results); } var resultStr = JsonConvert.SerializeObject(result); return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", resultStr } }, Data = resultStr })); } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message, Output = new Dictionary <string, string> { }, Data = string.Empty })); } }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <MathProcessActionSetting>(actionSetting); try { decimal arg1 = decimal.Parse(argument.Format(setting.Arg1)); decimal arg2 = decimal.Parse(argument.Format(setting.Arg2)); decimal res = 0; switch (setting.Action.ToLower()) { case "+": res = arg1 + arg2; break; case "-": res = arg1 - arg2; break; case "*": res = arg1 * arg2; break; case "/": if (arg2 == 0) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = $"You cannot divide by zero!" })); } res = arg1 / arg2; break; case "%": if (arg2 == 0) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = $"You cannot divide by zero!" })); } res = arg1 % arg2; break; case "abs": res = Math.Abs(arg1); break; case "ceiling": res = Math.Ceiling(arg1); break; case "floor": res = Math.Floor(arg1); break; default: return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = $"Action ({setting.Action}) is not known" })); } return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", res.ToString() } }, Data = res.ToString() })); } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message })); } }
private async Task <OperationResult <string> > CallHttp(ArgumentProvider argument) { var url = argument.Format(Settings.Url); var call = HttpProvider.CallUrl(url); var headers = new List <KeyValuePair <string, string> >(); if (Settings.Headers?.Any() == true) { foreach (var kvp in Settings.Headers) { var headerValue = argument.Format(kvp.Value); headers.Add(new KeyValuePair <string, string>(kvp.Key, headerValue)); call.WithHeader(kvp.Key, headerValue); } } call.AcceptStatusCodes(Settings.SuccessStatusCodes.Select(x => (HttpStatusCode)x).ToArray()); string body = string.Empty; if (!string.IsNullOrEmpty(Settings.Body)) { body = argument.Format(Settings.Body); call.WithJsonBody(body.ToJsonObject()); } if (Settings.FormData?.Any() == true) { var formData = new List <KeyValuePair <string, string> >(); foreach (var kvp in Settings.FormData) { var formValue = argument.Format(kvp.Value); formData.Add(new KeyValuePair <string, string>(kvp.Key, formValue)); call.WithHttpParameter(kvp.Key, formValue); } body = JsonConvert.SerializeObject(formData); } var executionData = new { Settings.Method, url, headers, body }; argument.PutPrivate(nameof(executionData), JsonConvert.SerializeObject(executionData)); if ("get".Equals(Settings.Method, StringComparison.CurrentCultureIgnoreCase)) { return(await call.GetAsync()); } else if ("post".Equals(Settings.Method, StringComparison.CurrentCultureIgnoreCase)) { return(await call.PostAsync <string>()); } else if ("put".Equals(Settings.Method, StringComparison.CurrentCultureIgnoreCase)) { return(await call.PutAsync <string>()); } else if ("delete".Equals(Settings.Method, StringComparison.CurrentCultureIgnoreCase)) { return(await call.DeleteAsync <string>()); } return(new OperationResult <string> { Success = false, Code = Messages.UnsupportedHttpMethod.Code, Message = Messages.UnsupportedHttpMethod.Message }); }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <CompareNumberActionSetting>(actionSetting); try { var arg1 = argument.Format(setting.Arg1); var arg2 = argument.Format(setting.Arg2); if (decimal.TryParse(arg1, out decimal d1) && decimal.TryParse(arg2, out decimal d2)) { bool result = false; switch (setting.Comparer.ToLower()) { case "greater": case ">": result = d1 > d2; break; case "greaterorequal": case ">=": result = d1 >= d2; break; case "equal": case "=": result = d1 == d2; break; case "less": case "<": result = d1 < d2; break; case "lessorequal": case "<=": result = d1 <= d2; break; case "notequal": case "<>": case "!=": result = d1 != d2; break; default: return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = $"Comparer ({setting.Comparer}) is not known" })); } return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", result.ToString() } }, Data = result.ToString() })); } else { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = $"Cannot compare {arg1} and {arg2}" })); } } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message })); } }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <SetValueActionSetting>(actionSetting); var results = new Dictionary <string, JToken>(); foreach (var kvp in setting.Set) { var target = argument.Format(kvp.Key, true); ExpressionModel expression = new ExpressionModel(string.Empty, target); var currentKey = expression.CurrentKey; if (expression.IsArray) { currentKey = expression.ArrayKey; } var obj = argument.Get(currentKey, true); if (obj != null && !(JsonHelper.IsObject(obj) || JsonHelper.IsArray(obj))) { obj = null; } if (obj == null) { string targetValue = argument.Format(kvp.Value, true); if (setting.AsString) { results.Add(target, targetValue); } else { var valueObj = JsonHelper.TryGetObject(targetValue, kvp.Value); var valueArr = JsonHelper.TryGetArray(targetValue, kvp.Value); if (valueObj != null) { targetValue = JsonConvert.SerializeObject(valueObj); results.Add(target, valueObj); } else if (valueArr != null) { targetValue = JsonConvert.SerializeObject(valueArr); results.Add(target, valueArr); } else { results.Add(target, targetValue); } } argument.PutPrivate(target, targetValue); } else { JToken token = null; JToken res = null; if (expression.IsArray) { JArray arr = JsonHelper.GetArray(obj, currentKey); res = JsonHelper.FindToken(arr[expression.Index], expression.SubExpression.Key, currentKey); if (res == null) { arr = FillArrayToCount(arr, expression.Index ?? 0); if (arr[expression.Index] == null) { arr[expression.Index] = CreateObject(new JObject(), expression.SubExpression); res = JsonHelper.FindToken(arr[expression.Index], expression.SubExpression.Key, currentKey); } } token = arr; } else { JObject o = JsonHelper.GetObject(obj, currentKey); res = JsonHelper.FindToken(o, expression.SubExpression.Key, currentKey); if (res == null) { o = CreateObject(o, expression.SubExpression); res = JsonHelper.FindToken(o, expression.SubExpression.Key, currentKey); } token = o; } if (res?.Parent != null) { var prop = (JProperty)res.Parent; var newValue = argument.Format(kvp.Value, true); if (setting.AsString) { prop.Value = newValue; } else if (JsonHelper.IsArray(newValue)) { JArray newArr = JsonHelper.GetArray(newValue, kvp.Value); prop.Value = newArr; } else if (JsonHelper.IsObject(newValue)) { JObject newObj = JsonHelper.GetObject(newValue, kvp.Value); prop.Value = newObj; } else { prop.Value = newValue; } } argument.PutPrivate(currentKey, JsonConvert.SerializeObject(token)); results.Add(currentKey, token); } } return(Task.FromResult(new ActionExecuteResult { Success = true, Data = JsonConvert.SerializeObject(results) })); }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <CompareActionSetting>(actionSetting); try { var arg1 = argument.Format(setting.Arg1); var arg2 = argument.Format(setting.Arg2); var args = setting.Args?.Select(x => argument.Format(x)); if (setting.IgnoreCase) { arg1 = arg1?.ToLower(); arg2 = arg2?.ToLower(); args = args?.Select(x => x?.ToLower()); } bool result = false; switch (setting.Comparer.ToLower()) { case "equal": case "=": result = arg1 == arg2; break; case "notequal": case "<>": case "!=": result = arg1 != arg2; break; case "in": result = args?.Contains(arg1) ?? false; break; case "notin": result = !(args?.Contains(arg1) ?? false); break; default: return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = $"Comparer ({setting.Comparer}) is not known" })); } return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", result.ToString() } }, Data = result.ToString() })); } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message })); } }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <CompareListActionSetting>(actionSetting); try { var listStr = argument.Format(setting.Source); var list = JsonHelper.GetArray(listStr, setting.Source); string methodSetting = JsonConvert.SerializeObject(setting.ActionSetting); bool result = false; switch (setting.Comparer) { case "any": result = list.Any(x => { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("sourceItem"); tmpArgument.PutPrivate("sourceItem", x.ToString()); return(ExecuteAction(setting.Action, methodSetting, tmpArgument).Result?.Success == true); }); break; case "all": result = list.All(x => { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("sourceItem"); tmpArgument.PutPrivate("sourceItem", x.ToString()); return(ExecuteAction(setting.Action, methodSetting, tmpArgument).Result?.Success == true); }); break; case "notany": result = !list.Any(x => { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("sourceItem"); tmpArgument.PutPrivate("sourceItem", x.ToString()); return(ExecuteAction(setting.Action, methodSetting, tmpArgument).Result?.Success == true); }); break; case "notall": result = !list.All(x => { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("sourceItem"); tmpArgument.PutPrivate("sourceItem", x.ToString()); return(ExecuteAction(setting.Action, methodSetting, tmpArgument).Result?.Success == true); }); break; default: return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = $"Comparer ({setting.Comparer}) is not known" })); } return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", result.ToString() } }, Data = result.ToString() })); } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message })); } }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <ExpandActionSetting>(actionSetting); var listJson = argument.Format(setting.Source); try { var list = JsonHelper.GetArray(listJson, setting.Source);; var result = new List <Dictionary <string, JToken> >(); foreach (var listItem in list) { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("sourceItem"); tmpArgument.PutPrivate("sourceItem", listItem.ToString()); var target = setting.Target; if (target.StartsWith("{{") && target.EndsWith("}}")) { target = target.Substring(2, target.Length - 4); } var targetJson = tmpArgument.Format($"{{{{sourceItem.{target}}}}}", true); var targetList = JsonHelper.GetArray(targetJson, target); foreach (var targetItem in targetList) { var tmpArgument2 = new ArgumentProvider(tmpArgument.WorkingArguments.Copy()); tmpArgument.ClearKey("targetItem"); tmpArgument2.PutPrivate("targetItem", targetItem.ToString()); if (setting?.Where?.Any() != true || setting?.Where?.Any(x => x.Indicate(tmpArgument2) ?? false) == true) { Dictionary <string, JToken> results = new Dictionary <string, JToken>(); foreach (var rule in setting.Output) { string targetValue = tmpArgument2.Format(rule.Value, true); if (JsonHelper.IsObject(targetValue)) { results.Add(rule.Key, JsonHelper.TryGetObject(targetValue, rule.Value)); } else if (JsonHelper.IsArray(targetValue)) { results.Add(rule.Key, JsonHelper.TryGetArray(targetValue, rule.Value)); } else { results.Add(rule.Key, targetValue); } } result.Add(results); } } } var resultStr = JsonConvert.SerializeObject(result); return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", resultStr } }, Data = resultStr })); } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message, Output = new Dictionary <string, string> { }, Data = string.Empty })); } }
/// <summary> /// execute /// </summary> /// <param name="actionSetting"></param> /// <param name="argument"></param> /// <returns></returns> public Task <ActionExecuteResult> Execute(string actionSetting, ArgumentProvider argument) { var setting = JsonConvert.DeserializeObject <AggregateActionSetting>(actionSetting); var listJson = argument.Format(setting.Source); try { var list = JsonHelper.GetArray(listJson, setting.Source); if (string.Equals("sum", setting?.Action, StringComparison.CurrentCultureIgnoreCase)) { // sum var sum = 0; foreach (var listItem in list) { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("sourceItem"); tmpArgument.PutPrivate("sourceItem", listItem.ToString()); if (setting?.Where?.Any() != true || setting?.Where?.Any(x => x.Indicate(tmpArgument) ?? false) == true) { var targetJson = tmpArgument.Format(setting.Target, true); sum += targetJson.ToNullableInt() ?? 0; } } return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", $"{sum}" } }, Data = $"{sum}" })); } else if (string.Equals("count", setting?.Action, StringComparison.CurrentCultureIgnoreCase)) { // count var count = 0; foreach (var listItem in list) { var tmpArgument = new ArgumentProvider(argument.WorkingArguments.Copy()); tmpArgument.ClearKey("sourceItem"); tmpArgument.PutPrivate("sourceItem", listItem.ToString()); if (setting?.Where?.Any() != true || setting?.Where?.Any(x => x.Indicate(tmpArgument) ?? false) == true) { count++; } } return(Task.FromResult(new ActionExecuteResult { Success = true, Output = new Dictionary <string, string> { { "result", $"{count}" } }, Data = $"{count}" })); } return(Task.FromResult(new ActionExecuteResult { Success = false, Output = new Dictionary <string, string> { { "result", "Unknow action" } }, Data = "Unknow action" })); } catch (Exception ex) { return(Task.FromResult(new ActionExecuteResult { Fail = true, Message = ex.Message, Output = new Dictionary <string, string> { }, Data = string.Empty })); } }