public static string DoCallback(string evt, string notifiableId, Dictionary <String, Object> payload = null)
{
try
{
var postArgs = new Dictionary <string, string>
{
{ "signature", GlobalDataPackage.Signature },
{ "rtid", GlobalDataPackage.RTID },
{ "id", notifiableId },
{ "on", "Complete" },
{ "event", evt }
};
if (payload != null)
{
postArgs["payload"] = JsonConvert.SerializeObject(payload);
}
NetClient.PostData(GlobalDataPackage.URL_Callback, postArgs, out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var retResponse = ReturnDataHelper.DecodeString(response);
LogUtils.LogLine("Request callback send OK: " + retResponse, LogLevel.Important);
return(retResponse);
}
catch (Exception ex)
{
LogUtils.LogLine("Request callback send, exception occurred" + ex, LogLevel.Error);
return(null);
}
}
public static List <Tuple <String, String, String> > GetWorkitemNameIdOneHandlerInVector()
{
var retList = new List <Tuple <String, String, String> >();
try
{
var argDict = new Dictionary <string, string>
{
{ "signature", Ren.transaction.Signature },
{ "rtid", Ren.rtid }
};
NetClient.PostData(GlobalContext.LocationDict["GetAllWorkitem"], argDict, out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var workitemList = ReturnDataHelper.DecodeList(response);
foreach (var workitem in workitemList)
{
var wd = ReturnDataHelper.DecodeDictionaryByString(workitem.ToString());
var workerIdListDesc = wd["WorkerIdList"].ToString();
var workerIdList = JsonConvert.DeserializeObject <List <String> >(workerIdListDesc);
retList.Add(new Tuple <string, string, string>(workerIdList.Last(), wd["Wid"].ToString(), wd["TaskName"].ToString()));
}
return(retList);
}
catch (Exception ex)
{
LogUtils.LogLine("Get all workitems, exception occurred" + ex, LogLevel.Error);
return(null);
}
}
public static void DoQueryBestDecompose(string rtid, string nodeId, string workitemId)
{
var dSet = DBUtil.CommitToDB($"select * from ren_decompose where rtid = \"{rtid}\" and nodeId = \"{nodeId}\"").Tables[0];
var list = (from object row
in dSet.Rows
select row as DataRow
into rowItem
select new Tuple <string, int>(rowItem["decompose"].ToString(), Convert.ToInt32(rowItem["voted"].ToString()))).ToList();
var vote = -1;
var selected = "";
foreach (var tuple in list)
{
if (tuple.Item2 > vote)
{
vote = tuple.Item2;
selected = tuple.Item1;
}
}
var rList = ReturnDataHelper.DecodeListByString(selected);
var retDict = new Dictionary <string, object>();
for (var i = 0; i < rList.Count; i++)
{
retDict[i.ToString()] = rList[i];
}
InteractionManager.StartAndComplete(GlobalDataPackage.CurrentUserWorkerId, workitemId, retDict); // todo worker id of agent
}
public static List <Tuple <List <string>, Dictionary <String, String> > > GetMyWorkitem(string workerId, string rtid)
{
try
{
var argDict = new Dictionary <string, string>
{
{ "signature", GlobalDataPackage.Signature },
{ "rtid", rtid }
};
NetClient.PostData(GlobalDataPackage.URL_GetAllWorkitem, argDict, out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var workitemList = ReturnDataHelper.DecodeList(response);
var retList = new List <Tuple <List <string>, Dictionary <String, String> > >();
retList.AddRange(
from workitem
in workitemList
select ReturnDataHelper.DecodeDictionaryByString(workitem.ToString())
into wd
let workerIdListDesc = wd["WorkerIdList"]
let workerIdList = JsonConvert.DeserializeObject <List <String> >(workerIdListDesc)
select new Tuple <List <string>, Dictionary <String, String> >(workerIdList, wd));
return(retList.FindAll(t => t.Item1.Contains(workerId)));
}
catch (Exception ex)
{
LogUtils.LogLine("Get workitems, exception occurred" + ex, LogLevel.Error);
return(null);
}
}
public static StdResponseEntity PostWorkitemRequest(string desc, string urlKey, string workerId, string workitemId, Dictionary <String, Object> payload = null)
{
try
{
var argDict = new Dictionary <string, string>
{
{ "signature", GlobalDataPackage.Signature },
{ "workitemId", workitemId },
{ "workerId", workerId },
};
if (payload != null)
{
argDict["payload"] = JsonConvert.SerializeObject(payload);
}
NetClient.PostData(urlKey, argDict, out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
LogUtils.LogLine(desc + "(" + urlKey + ") get response: " + ReturnDataHelper.DecodeString(response), LogLevel.Important);
return(response);
}
catch (Exception ex)
{
LogUtils.LogLine(desc + ", exception occurred" + ex, LogLevel.Error);
return(null);
}
}
public static void PerformCheckFinish()
{
try
{
NetClient.PostData(GlobalContext.LocationDict["CheckFinish"], new Dictionary <string, string>
{
{ "signature", Ren.transaction.Signature },
{ "rtid", Ren.rtid }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var retDict = ReturnDataHelper.DecodeToStringStringDictionary(response);
LogUtils.LogLine("CheckFinish send OK: " + ReturnDataHelper.DecodeString(response), LogLevel.Important);
if (retDict["IsFinished"] == "true")
{
LogUtils.LogLine(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IsFinish flag is TRUE! Test Passed!", LogLevel.Important);
}
else
{
LogUtils.LogLine(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> IsFinish flag is FALSE!", LogLevel.Error);
}
}
catch (Exception ex)
{
LogUtils.LogLine("CheckFinish send, exception occurred" + ex, LogLevel.Error);
}
}
public static void PerformLogin()
{
try
{
NetClient.PostData(GlobalContext.LocationDict["Login"],
new Dictionary <string, string>
{
{ "username", "admin@admin" },
{ "password", "admin" }
},
out string retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var retToken = ReturnDataHelper.DecodeString(response);
var successFlag = !retToken.StartsWith("#");
if (successFlag)
{
LogUtils.LogLine("Login OK, Token: " + retToken, LogLevel.Important);
transaction.AuthToken = retToken;
}
else
{
LogUtils.LogLine("Login Failed. ", LogLevel.Error);
}
}
catch (Exception ex)
{
LogUtils.LogLine("PerformLogin exception occurred" + ex, LogLevel.Error);
}
}
/// <summary>
/// Step1 Button: Next.
/// </summary>
private void Button_Step1_Next_OnClick(object sender, RoutedEventArgs e)
{
if (this.ComboBox_Step1_Processes.SelectedIndex == 0) // new process
{
if (this.ListBox_Step1_BO.Items.Count == 0)
{
MessageBox.Show(@"A process should contain at lease one BO");
return;
}
if (this.ComboBox_Step1_MainBO.SelectedIndex == -1)
{
MessageBox.Show(@"There must have a main BO");
return;
}
var npf = new ProcessNameForm();
npf.ShowDialog();
if (npf.ProcessName == null)
{
return;
}
// create new process
var pid = MPController.CreateProcess(npf.ProcessName,
this.ComboBox_Step1_MainBO.SelectedItem.ToString().Trim());
if (String.IsNullOrEmpty(pid))
{
MessageBox.Show(@"Failed to create new process");
return;
}
MPController.CurrentTransaction.ProcessName = npf.ProcessName;
MPController.CurrentTransaction.ProcessPID = pid;
var BRList = new List <string>();
// upload BO Content
foreach (var boDict in MPController.CurrentTransaction.BOVector)
{
var retKVP = MPController.UploadBO(boDict["bo_name"], boDict["bo_content"]).First();
boDict["boid"] = retKVP.Key;
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retKVP.Value);
var responseDict = ReturnDataHelper.DecodeList(response);
BRList.AddRange(responseDict.Select(br => br.ToString()));
}
MPController.CurrentTransaction.BusinessRoleList = new HashSet <string>();
foreach (var br in BRList)
{
MPController.CurrentTransaction.BusinessRoleList.Add(br);
}
}
else // exist process
{
if (this.ComboBox_Step1_MainBO.Items.Count == 0)
{
MessageBox.Show(@"There must be a Main BO");
return;
}
MPController.CurrentTransaction.ProcessName = this.ComboBox_Step1_Processes.SelectedItem.ToString();
MPController.CurrentTransaction.ProcessPID =
GlobalContext.Current_Ren_Process_List[this.ComboBox_Step1_Processes.SelectedIndex - 1]["pid"];
}
this.tabControl.SelectedIndex += 1;
}
public static Dictionary <String, String> UploadBO(string boName, string content)
{
NetClient.PostData(GlobalContext.LocationDict["UploadBO"], new Dictionary <string, string>
{
{ "token", transaction.AuthToken },
{ "pid", transaction.ProcessPID },
{ "name", boName },
{ "content", System.Web.HttpUtility.UrlEncode(content, Encoding.UTF8) }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
return(ReturnDataHelper.DecodeToStringStringDictionary(response));
}
public static void PerformUploadProcess()
{
try
{
Ren.LoadProcessFromDirectory(IOUtils.ParseURItoURL("processDir"));
var processName = "RestaurantTest_" + DateTime.Now.ToString().Replace(' ', '_');
LogUtils.LogLine("Process Name is: " + processName + "\nMainBO: GuestOrder", LogLevel.Normal);
NetClient.PostData(GlobalContext.LocationDict["CreateProcess"],
new Dictionary <string, string>
{
{ "token", Ren.transaction.AuthToken },
{ "renid", "admin@admin" },
{ "name", processName },
{ "mainbo", "GuestOrder" }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
Ren.transaction.ProcessPID = ReturnDataHelper.DecodeString(response);
Ren.transaction.ProcessName = processName;
if (String.IsNullOrEmpty(Ren.transaction.ProcessPID))
{
LogUtils.LogLine("Failed to create process. " + response, LogLevel.Error);
}
else
{
LogUtils.LogLine("Create Process OK, PID: " + Ren.transaction.ProcessPID, LogLevel.Important);
}
// upload BO Content
var BRList = new List <string>();
foreach (var boDict in Ren.transaction.BOVector)
{
var retKVP = Ren.UploadBO(boDict["bo_name"], boDict["bo_content"]).First();
boDict["boid"] = retKVP.Key;
response = JsonConvert.DeserializeObject <StdResponseEntity>(retKVP.Value);
var responseDict = ReturnDataHelper.DecodeList(response);
BRList.AddRange(responseDict.Select(br => br.ToString()));
}
Ren.transaction.BusinessRoleList = new HashSet <string>();
foreach (var br in BRList)
{
Ren.transaction.BusinessRoleList.Add(br);
}
}
catch (Exception ex)
{
LogUtils.LogLine("PerformUploadProcess exception occurred" + ex, LogLevel.Error);
}
}
public static Dictionary <String, String> UploadBO(string boName, string content)
{
try
{
NetClient.PostData(GlobalContext.LocationDict["UploadBO"], new Dictionary <string, string>
{
{ "token", Ren.transaction.AuthToken },
{ "pid", Ren.transaction.ProcessPID },
{ "name", boName },
{ "content", System.Web.HttpUtility.UrlEncode(content, Encoding.UTF8) }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
return(ReturnDataHelper.DecodeToStringStringDictionary(response));
}
catch (Exception ex)
{
LogUtils.LogLine("UploadBO exception occurred" + ex, LogLevel.Error);
return(null);
}
}
public static void PerformCallbackRequestCheck()
{
// 这个callback是用户发起的，与工作项无关，和其他不一样
try
{
NetClient.PostData(GlobalContext.LocationDict["Callback"], new Dictionary <string, string>
{
{ "signature", Ren.transaction.Signature },
{ "rtid", Ren.rtid },
{ "id", "GuestOrder" },
{ "on", "Complete" },
{ "event", "requestCheck" }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
LogUtils.LogLine("Request Check callback send OK: " + ReturnDataHelper.DecodeString(response), LogLevel.Important);
}
catch (Exception ex)
{
LogUtils.LogLine("Request Check callback send, exception occurred" + ex, LogLevel.Error);
}
}
public void RefreshList()
{
this.ListBox_Solver_Tasks.Items.Clear();
var rtids = CSCore.GetAllActiveRTID();
foreach (var rtid in rtids)
{
var workitems = InteractionManager.GetMyWorkitem(GlobalDataPackage.CurrentUserWorkerId, rtid);
foreach (var workitem in workitems)
{
var itemDict = workitem.Item2;
var request = CSCore.GetRequestByRTID(rtid);
var retArgs = ReturnDataHelper.DecodeDictionaryByString(itemDict["Argument"]);
var lbi = new ListBoxItem
{
Content = String.Format("Task: {0} | From CrowdSourcing Request: {1} | By: {2}",
itemDict["TaskName"], request.ItemArray[1], request.ItemArray[2]),
Tag = new Tuple <Dictionary <String, String>, Dictionary <String, String> >(itemDict, retArgs)
};
this.ListBox_Solver_Tasks.Items.Add(lbi);
}
}
}
private void ListBox_Solver_Tasks_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
if (this.ListBox_Solver_Tasks.SelectedIndex == -1)
{
return;
}
var listItem = this.ListBox_Solver_Tasks.SelectedItem as ListBoxItem;
var itemDict = (listItem.Tag as Tuple <Dictionary <String, String>, Dictionary <String, String> >).Item1;
//var argDict = (listItem.Tag as Tuple<Dictionary<String, String>, Dictionary<String, String>>).Item2;
//var request = CSCore.GetRequestByRTID(itemDict["Rtid"]);
var passedArguments = ReturnDataHelper.DecodeDictionaryByString(itemDict["Argument"]);
switch (itemDict["TaskName"])
{
case "judgeTask":
new JudgeTaskWindow(passedArguments["taskName"], passedArguments["taskDescription"], itemDict["Wid"]).ShowDialog();
break;
case "decomposeTask":
new DecomposeWindow(passedArguments["taskName"], passedArguments["taskDescription"], itemDict["Wid"], itemDict["Rtid"], itemDict["CallbackNodeId"]).ShowDialog();
break;
case "decomposeVoteTask":
new DecomposeVoteWindow(passedArguments["taskName"], passedArguments["taskDescription"], itemDict["Wid"], itemDict["Rtid"], itemDict["CallbackNodeId"]).ShowDialog();
break;
case "solveTask":
new SolveWindow(passedArguments["taskName"], passedArguments["taskDescription"], itemDict["Wid"], itemDict["Rtid"], itemDict["CallbackNodeId"]).ShowDialog();
break;
case "solveVoteTask":
new SolveVoteWindow(passedArguments["taskName"], passedArguments["taskDescription"], itemDict["Wid"], itemDict["Rtid"], itemDict["CallbackNodeId"]).ShowDialog();
break;
}
this.RefreshList();
}
/// <summary>
/// 启动流程准备测试
/// </summary>
public static void Prepare()
{
NetClient.PostData(GlobalContext.LocationDict["Login"],
new Dictionary <string, string>
{
{ "username", "admin@admin" },
{ "password", "admin" }
},
out string retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var retToken = ReturnDataHelper.DecodeString(response);
var successFlag = !retToken.StartsWith("#");
transaction.AuthToken = retToken;
LoadProcessFromDirectory(ParseURItoURL("processDir"));
var processName = "RestaurantTest_" + DateTime.Now.ToString().Replace(' ', '_');
NetClient.PostData(GlobalContext.LocationDict["CreateProcess"],
new Dictionary <string, string>
{
{ "token", transaction.AuthToken },
{ "renid", "admin@admin" },
{ "name", processName },
{ "mainbo", "GuestOrder" }
},
out retStr);
response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
transaction.ProcessPID = ReturnDataHelper.DecodeString(response);
transaction.ProcessName = processName;
var BRList = new List <string>();
foreach (var boDict in transaction.BOVector)
{
var retKVP = UploadBO(boDict["bo_name"], boDict["bo_content"]).First();
boDict["boid"] = retKVP.Key;
response = JsonConvert.DeserializeObject <StdResponseEntity>(retKVP.Value);
var responseDict = ReturnDataHelper.DecodeList(response);
BRList.AddRange(responseDict.Select(br => br.ToString()));
}
transaction.BusinessRoleList = new HashSet <string>();
foreach (var br in BRList)
{
transaction.BusinessRoleList.Add(br);
}
var CurrentMap = new List <KeyValuePair <string, string> >
{
new KeyValuePair <string, string>("waiter", GlobalContext.WorkerId)
};
transaction.Mappings = new List <KeyValuePair <string, string> >();
foreach (var mapItem in CurrentMap)
{
transaction.Mappings.Add(mapItem);
}
transaction.LaunchType = 0;
transaction.IsolationType = 0;
transaction.FailureType = 0;
transaction.AuthType = 0;
transaction.RenUsername = "******";
NetClient.PostData(GlobalContext.LocationDict["SubmitProcess"], new Dictionary <string, string>
{
{ "token", transaction.AuthToken },
{ "pid", transaction.ProcessPID },
{ "from", "SpeedTester.NET" },
{ "renid", transaction.RenUsername },
{ "bindingType", transaction.IsolationType.ToString() },
{ "launchType", transaction.LaunchType.ToString() },
{ "failureType", transaction.FailureType.ToString() },
{ "authType", transaction.AuthType.ToString() },
{ "binding", "" }
},
out retStr);
response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var submitRes = ReturnDataHelper.DecodeString(response);
var submitResItem = submitRes.Split(',');
NetClient.rtid = submitResItem[0];
NetClient.PostData(GlobalContext.LocationDict["UploadMapping"], new Dictionary <string, string>
{
{ "token", transaction.AuthToken },
{ "rtid", NetClient.rtid },
{ "organgid", "COrg_571d200f-0f35-11e8-9072-5404a6a99e5d" },
{ "dataversion", "version1" },
{ "map", GeneratePostMapStringOfMappings() }
},
out retStr);
response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
NetClient.PostData(GlobalContext.LocationDict["LoadParticipant"], new Dictionary <string, string>
{
{ "token", transaction.AuthToken },
{ "rtid", NetClient.rtid },
{ "renid", transaction.RenUsername }
},
out retStr);
response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
NetClient.PostData(GlobalContext.LocationDict["StartProcess"], new Dictionary <string, string>
{
{ "token", transaction.AuthToken },
{ "rtid", NetClient.rtid }
},
out retStr);
response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
NetClient.BeginTimestamp = DateTime.Now;
}
public static List <Tuple <string, List <string> > > GetDecomposeList(string rtid, string nodeId)
{
var dSet = DBUtil.CommitToDB($"select * from ren_decompose where rtid = \"{rtid}\" and nodeId = \"{nodeId}\"").Tables[0];
return((from object row
in dSet.Rows
select row as DataRow
into rowItem
select new Tuple <string, List <string> >(rowItem["workerId"].ToString(), ReturnDataHelper.DecodeListByString(rowItem["decompose"].ToString()))).ToList());
}
public static void SubmitAndStart()
{
try
{
NetClient.PostData(GlobalDataPackage.URL_Login,
new Dictionary <string, string>
{
{ "username", "admin@admin" },
{ "password", "admin" }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var retToken = ReturnDataHelper.DecodeString(response);
var successFlag = !retToken.StartsWith("#");
if (successFlag)
{
LogUtils.LogLine("Login OK, Token: " + retToken, LogLevel.Important);
GlobalDataPackage.AuthToken = retToken;
}
else
{
LogUtils.LogLine("Login Failed. ", LogLevel.Error);
}
}
catch (Exception ex)
{
LogUtils.LogLine("PerformLogin exception occurred" + ex, LogLevel.Error);
}
try
{
NetClient.PostData(GlobalDataPackage.URL_SubmitProcess, new Dictionary <string, string>
{
{ "token", GlobalDataPackage.AuthToken },
{ "pid", GlobalDataPackage.ProcessPID },
{ "from", "CrowdSourcing.NET" },
{ "renid", "admin@admin" },
{ "bindingType", "0" },
{ "launchType", "0" },
{ "failureType", "0" },
{ "authType", "0" },
{ "binding", "" }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var submitRes = ReturnDataHelper.DecodeString(response);
var submitResItem = submitRes.Split(',');
GlobalDataPackage.RTID = submitResItem[0];
LogUtils.LogLine("Submit Process OK, RTID: " + GlobalDataPackage.RTID, LogLevel.Important);
}
catch (Exception ex)
{
LogUtils.LogLine("Submit process, exception occurred" + ex, LogLevel.Error);
return;
}
try
{
NetClient.PostData(GlobalDataPackage.URL_UploadMapping, new Dictionary <string, string>
{
{ "token", GlobalDataPackage.AuthToken },
{ "rtid", GlobalDataPackage.RTID },
{ "organgid", "COrg_571d200f-0f35-11e8-9072-5404a6a99e5d" },
{ "dataversion", "version1" },
{ "map", InteractionManager.GeneratePostMapStringOfMappings() }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
LogUtils.LogLine("Mapping BRole Send OK, Response: " + ReturnDataHelper.DecodeString(response), LogLevel.Important);
}
catch (Exception ex)
{
LogUtils.LogLine("Register mappings, exception occurred" + ex, LogLevel.Error);
}
try
{
NetClient.PostData(GlobalDataPackage.URL_LoadParticipant, new Dictionary <string, string>
{
{ "token", GlobalDataPackage.AuthToken },
{ "rtid", GlobalDataPackage.RTID },
{ "renid", "admin@admin" }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
LogUtils.LogLine("LoadParticipant Send OK, Response: " + ReturnDataHelper.DecodeString(response), LogLevel.Important);
}
catch (Exception ex)
{
LogUtils.LogLine("Register mappings, exception occurred" + ex, LogLevel.Error);
}
try
{
NetClient.PostData(GlobalDataPackage.URL_StartProcess, new Dictionary <string, string>
{
{ "token", GlobalDataPackage.AuthToken },
{ "rtid", GlobalDataPackage.RTID }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
LogUtils.LogLine("StartProcess send OK, Response: " + ReturnDataHelper.DecodeString(response), LogLevel.Important);
}
catch (Exception ex)
{
LogUtils.LogLine("Register mappings, exception occurred" + ex, LogLevel.Error);
}
}
public static void PerformSubmitAndStart()
{
Ren.transaction.LaunchType = 0;
Ren.transaction.IsolationType = 0;
Ren.transaction.FailureType = 0;
Ren.transaction.AuthType = 0;
Ren.transaction.RenUsername = "******";
try
{
NetClient.PostData(GlobalContext.LocationDict["SubmitProcess"], new Dictionary <string, string>
{
{ "token", Ren.transaction.AuthToken },
{ "pid", Ren.transaction.ProcessPID },
{ "from", "ProcessTester.NET" },
{ "renid", Ren.transaction.RenUsername },
{ "bindingType", Ren.transaction.IsolationType.ToString() },
{ "launchType", Ren.transaction.LaunchType.ToString() },
{ "failureType", Ren.transaction.FailureType.ToString() },
{ "authType", Ren.transaction.AuthType.ToString() },
{ "binding", "" } // todo static Resources.xml
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
var submitRes = ReturnDataHelper.DecodeString(response);
var submitResItem = submitRes.Split(',');
Ren.rtid = submitResItem[0];
LogUtils.LogLine("Submit Process OK, RTID: " + Ren.rtid, LogLevel.Important);
}
catch (Exception ex)
{
LogUtils.LogLine("Submit process, exception occurred" + ex, LogLevel.Error);
return;
}
try
{
NetClient.PostData(GlobalContext.LocationDict["UploadMapping"], new Dictionary <string, string>
{
{ "token", Ren.transaction.AuthToken },
{ "rtid", Ren.rtid },
{ "organgid", "COrg_571d200f-0f35-11e8-9072-5404a6a99e5d" },
{ "dataversion", "version1" },
{ "map", Ren.GeneratePostMapStringOfMappings() }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
LogUtils.LogLine("Mapping BRole Send OK, Response: " + ReturnDataHelper.DecodeString(response), LogLevel.Important);
}
catch (Exception ex)
{
LogUtils.LogLine("Register mappings, exception occurred" + ex, LogLevel.Error);
}
try
{
NetClient.PostData(GlobalContext.LocationDict["LoadParticipant"], new Dictionary <string, string>
{
{ "token", Ren.transaction.AuthToken },
{ "rtid", Ren.rtid },
{ "renid", Ren.transaction.RenUsername }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
LogUtils.LogLine("LoadParticipant Send OK, Response: " + ReturnDataHelper.DecodeString(response), LogLevel.Important);
}
catch (Exception ex)
{
LogUtils.LogLine("Register mappings, exception occurred" + ex, LogLevel.Error);
}
try
{
NetClient.PostData(GlobalContext.LocationDict["StartProcess"], new Dictionary <string, string>
{
{ "token", Ren.transaction.AuthToken },
{ "rtid", Ren.rtid }
},
out var retStr);
var response = JsonConvert.DeserializeObject <StdResponseEntity>(retStr);
LogUtils.LogLine("StartProcess send OK, Response: " + ReturnDataHelper.DecodeString(response), LogLevel.Important);
}
catch (Exception ex)
{
LogUtils.LogLine("Register mappings, exception occurred" + ex, LogLevel.Error);
}
}
