private void solveVotingWorkflowCompleted(WorkflowApplicationCompletedEventArgs e)
{
//保存到解决投票表里面
MyWorkflowInstance.removeSolveVotingWorkflowApplication(e.InstanceId.ToString());
CrowdTask crowdTask = new CrowdTask();
CrowdTaskService crowdTaskService = new CrowdTaskService();
crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(e.InstanceId.ToString());
//将当前流程的投票的分解的工作流ID写入数据库
int result = crowdTaskService.saveSolveVoteResult1(e.InstanceId.ToString(), (string)e.Outputs["out_bestSolutionWorkflowId"]);
//如果所有的解决投票任务完成了。开启投票
if (MyWorkflowInstance.getSolveVotingWorkflowApplications().Count == 0)
{
//更新得到最佳答案；
ArrayList allSolveCompeletedCrowdTask = crowdTaskService.findAllSolveCompeletedCrowdTaskByMainTaskId(crowdTask.mainTaskId);
//得到每一个解决任务的名字，然后根据名字和描述再去加载解决任务的ID，得到ID之后再去判断是不是最佳答案
foreach (SolveResult sr in allSolveCompeletedCrowdTask)
{
ArrayList al = crowdTaskService.finSolveResultByMainTaskIdAndTaskName(crowdTask.mainTaskId, sr.taskName);
int[] supportedNumber = new int[ConstantDefine.solvingNumber];
string[] supportedWorkflowId = new string[ConstantDefine.solvingNumber];
int i = 0;
foreach (SolveResult item in al)
{
//拿到每一个ID 当做supportedId，去数据库里面比对
supportedNumber[i] = crowdTaskService.getSolveVoteResultBySupportedId(item.taskWorkflowId);
supportedWorkflowId[i] = item.taskWorkflowId;
i++;
}
int maxNumber = supportedNumber[0];
string maxWorkflowId = supportedWorkflowId[0];
for (int j = 0; j < al.Count; j++)
{
if (supportedNumber[j] > maxNumber)
{
maxNumber = supportedNumber[j];
maxWorkflowId = supportedWorkflowId[j];
}
}
//找到了最佳答案，更新。
crowdTaskService.updateSolveResultBestAnswer(maxWorkflowId);
}
//更新书签
MyWorkflowInstance.getWorkflowApplication(crowdTask.mainTaskId).ResumeBookmark(BookmarkName.SolveVoting, null);
//生成分解树。
crowdTaskService.writeDecomposeTree(crowdTask.mainTaskId);
}
}
protected void Page_Load(object sender, EventArgs e)
{
taskWorkflowId = Request.Params["taskWorkflowId"];
crowdTaskService = new CrowdTaskService();
currentCrowdTask = crowdTaskService.findCrowdTaskByWorkflowId(taskWorkflowId);
TextBox1.Text = currentCrowdTask.taskName;
TextBox2.Text = currentCrowdTask.taskDescription;
TextBox3.Text = taskWorkflowId;
}
public void startDevideVotingProcess(Dictionary <string, ArrayList> solutionTasks)
{
//创建输入参数
Dictionary <string, object> para = new Dictionary <string, object>();
para.Add("solutionTasks", solutionTasks);
//创建实例对象
WorkflowApplication currentWorkflowInstance = new WorkflowApplication(new decomposeVoting(), para);
//委托流程结束时候调用的方法
currentWorkflowInstance.Completed = new Action <WorkflowApplicationCompletedEventArgs>(DevideVotingWorkflowCompleted);
//启动实例
currentWorkflowInstance.Run();
CrowdTaskService crowdTaskService = new CrowdTaskService();
//分解任务
CrowdTask divideTask = crowdTaskService.findCrowdTaskByWorkflowId(solutionTasks.First().Key);
CrowdTask crowdTask = new CrowdTask();
crowdTask.taskName = divideTask.taskName;
crowdTask.taskDescription = divideTask.taskDescription;
crowdTask.taskType = TaskType.decomposeVotingTask;
crowdTask.taskWorkflowId = currentWorkflowInstance.Id.ToString();
crowdTask.taskParentWorkflowId = crowdTaskService.findCrowdTaskByWorkflowId(solutionTasks.Keys.First().ToString()).taskParentWorkflowId;
int result = crowdTaskService.insert(crowdTask);
//更新每个实例的主工作流Id
crowdTaskService.updateCrowdTaskMainTaskIdByWorkflowId(currentWorkflowInstance.Id.ToString());
if (result == 1)
{
//将当前实例加入到分解任务集合中
MyWorkflowInstance.setDecomposeVotingWorkflowApplication(currentWorkflowInstance.Id.ToString(), currentWorkflowInstance);
}
}
protected void Page_Load(object sender, EventArgs e)
{
crowdTaskService = new CrowdTaskService();
CrowdTask crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(Request.Params["taskWorkflowId"]);
taskWorkflowId = crowdTask.taskWorkflowId;
TextBox1.Text = crowdTask.taskName;
TextBox2.Text = crowdTask.taskDescription;
TextBox3.Text = crowdTask.taskWorkflowId;
}
protected void Page_Load(object sender, EventArgs e)
{
crowdTaskService = new CrowdTaskService();
workflowId = Request.Params["workflowId"];
CrowdTask mainTask = crowdTaskService.findCrowdTaskByWorkflowId(workflowId);
String taskName = mainTask.taskName;
String taskDescription = mainTask.taskDescription;
TextBox1.Text = taskName;
TextBox2.Text = taskDescription;
TextBox3.Text = workflowId;
}
protected void Page_Load(object sender, EventArgs e)
{
crowdTaskService = new CrowdTaskService();
workflowId = Request.Params["workflowId"];
CrowdTask mainTask = crowdTaskService.findCrowdTaskByWorkflowId(workflowId);
String taskName = mainTask.taskName;
String taskDescription = mainTask.taskDescription;
TextBox1.Text = taskName;
TextBox2.Text = taskDescription;
TextBox3.Text = workflowId;
}
protected void Page_Load(object sender, EventArgs e)
{
taskWorkflowId = Request.Params["taskWorkflowId"];
crowdTaskService = new CrowdTaskService();
currentCrowdTask = crowdTaskService.findCrowdTaskByWorkflowId(taskWorkflowId);
TextBox1.Text = currentCrowdTask.taskName;
TextBox2.Text = currentCrowdTask.taskDescription;
TextBox3.Text = taskWorkflowId;
if (!IsPostBack)
{
ArrayList arrayList = new ArrayList();
arrayList.Add("请选择分解步数");
arrayList.Add(2);
arrayList.Add(3);
arrayList.Add(4);
arrayList.Add(5);
DropDownList1.DataSource = arrayList;
DropDownList1.DataBind();
}
}
protected void Page_Load(object sender, EventArgs e)
{
taskWorkflowId = Request.Params["taskWorkflowId"];
crowdTaskService = new CrowdTaskService();
currentCrowdTask = crowdTaskService.findCrowdTaskByWorkflowId(taskWorkflowId);
TextBox1.Text = currentCrowdTask.taskName;
TextBox2.Text = currentCrowdTask.taskDescription;
TextBox3.Text = taskWorkflowId;
if (!IsPostBack)
{
ArrayList arrayList = new ArrayList();
arrayList.Add("请选择分解步数");
arrayList.Add(2);
arrayList.Add(3);
arrayList.Add(4);
arrayList.Add(5);
DropDownList1.DataSource = arrayList;
DropDownList1.DataBind();
}
}
protected void Page_Load(object sender, EventArgs e)
{
//根据传过来的工作流ID，加载对应的实例
crowdTaskService = new CrowdTaskService();
//taskParentWorkflowId = Request.Params["parentWorkflowId"];
taskWorkflowId = Request.Params["taskWorkflowId"];
//得到任务实例
CrowdTask crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(taskWorkflowId);
TextBox1.Text = crowdTask.taskName;
TextBox2.Text = crowdTask.taskDescription;
//通过解决任务实例得到解决任务的同几个实例
//不应该根据分解任务的个数来生成表格，应该根据分解结果的个数来生成表格
list = crowdTaskService.findAllSonCrowdTaskByParentTaskNameAndTaskDescriptionAndTaskType(crowdTask.taskName, crowdTask.taskDescription, TaskType.solveTask, crowdTask.mainTaskId);
foreach (CrowdTask ct in list)
{
SolveResult solveResult = crowdTaskService.findSolveResultByWorkflowId(ct.taskWorkflowId, crowdTask.mainTaskId);
//创建显示解决结果的表格
Table table = new Table();
table.BorderWidth = 1;
TableHeaderRow tableHeaderRow = new TableHeaderRow();
TableHeaderCell tableHeaderCell1 = new TableHeaderCell();
tableHeaderCell1.Text = "工作流ID：";
TableHeaderCell tableHeaderCell2 = new TableHeaderCell();
tableHeaderCell2.Text = ct.taskWorkflowId;
TableHeaderCell tableHeaderCell3 = new TableHeaderCell();
RadioButton radioButton = new RadioButton();
radioButton.GroupName = "vote";
radioButton.ID = ct.taskWorkflowId;
tableHeaderCell3.Controls.Add(radioButton);
tableHeaderRow.Cells.Add(tableHeaderCell1);
tableHeaderRow.Cells.Add(tableHeaderCell2);
tableHeaderRow.Cells.Add(tableHeaderCell3);
table.Rows.Add(tableHeaderRow);
TableRow tr = new TableRow();
TableCell tc = new TableCell();
tc.Text = "解决方案";
TableCell tc1 = new TableCell();
tc1.Text = solveResult.taskSolution;
tr.Cells.Add(tc);
tr.Cells.Add(tc1);
table.Rows.Add(tr);
panel.Controls.Add(table);
}
}
void SubDivideWorkflowCompleted(WorkflowApplicationCompletedEventArgs e)
{
//流程结束，将流程实例移除
MyWorkflowInstance.removeDecomposeWorkflowApplication(e.InstanceId.ToString());
CrowdTaskService crowdTaskService = new CrowdTaskService();
//将当前流程的分解解决方案写入数据库
int result = crowdTaskService.saveDecomposeResult(e.InstanceId.ToString(),(ArrayList)e.Outputs["out_arraylist_task"]);
//得到当前分解任务的内容
CrowdTask crowdTask = new CrowdTask();
crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(e.InstanceId.ToString());
//通过当前分解任务的父工作流ID ，获得该父工作流的所有子工作流，如果都完成了则开启分解判断过程
ArrayList allSonCrowdTask = crowdTaskService.findAllSonCrowdTaskByParentWorkflowIdAndTaskName(crowdTask.taskParentWorkflowId, crowdTask.taskName,crowdTask.mainTaskId);
Dictionary<string, ArrayList> solutionTasks = new Dictionary<string, ArrayList>();
int count = 0;
//遍历看看这个任务的同一级的分解任务是否都结束了
foreach (CrowdTask ct in allSonCrowdTask)
{
WorkflowApplication wa = MyWorkflowInstance.getDecomposeWorkflowApplication(ct.taskWorkflowId);
if (wa != null)
{
break;
}
else
{
count++;
}
}
//如果都结束了
if (count == ConstantDefine.divideNumber)
{
//获得每一个分解任务给出的解决方案
foreach (CrowdTask ct in allSonCrowdTask)
{
ArrayList solutions = crowdTaskService.findDecomposeResultByWorkflowId(ct.taskWorkflowId,ct.mainTaskId);
if (solutions.Count != 0)
{
//表示当前工作流Id给出了分解方案
solutionTasks.Add(ct.taskWorkflowId, solutions);
}
}
//表示至少有一个分解任务给出了解决方案
if (solutionTasks.Count != 0)
{
//开启5个投票流程 工作流实例
for (int i = 0; i < ConstantDefine.decomposeVotingNumber; i++)
{
StartSubProcess ssp = new StartSubProcess();
ssp.startDevideVotingProcess(solutionTasks);
}
}
//表示所有的当前这几个分解任务都认为这个任务是简单任务，设置简单标记
else
{
//当前一个任务判定为简单，是要等这一层级的所有任务都判定完了在根据情况，把这一层是简单的任务抛出去
foreach (CrowdTask ct in allSonCrowdTask)
{
int h = crowdTaskService.updateDecomposeResultByWokflowIdAndTaskName(ct.taskParentWorkflowId, ct.taskName,ct.mainTaskId);
}
}
/*
//等待这一层的所有任务都分解完成了，把这一层的简单任务选出来，分发出去
ArrayList ThisLayerAllSonCrowdTask = crowdTaskService.findCrowdTaskByParentWorkflowIdAndTaskType(crowdTask.taskParentWorkflowId, TaskType.decomposeTask);
int count1 = 0;
//遍历这一层的任务，看看是否都完成了
foreach (CrowdTask ct in ThisLayerAllSonCrowdTask)
{
WorkflowApplication wa = MyWorkflowInstance.getDecomposeWorkflowApplication(ct.taskWorkflowId);
if (wa != null)
{
break;
}
else
{
count1++;
}
}
//这一层的所有任务都完成了
if (ThisLayerAllSonCrowdTask.Count == count1)
{
ArrayList al_simple = crowdTaskService.getAllThisLayerNeedSolvedCrowTaskInDecomposeResult(crowdTask.taskParentWorkflowId);
//可以得到这一层一共有多少个简单任务
//将每一个简单任务分发出去启动解决流程
foreach (DecomposeResult al in al_simple)
{
for (int k = 0; k < ConstantDefine.solvingNumber; k++)
{
//将这个任务分发出去
CrowdTask ct = new CrowdTask();
ct.taskName = al.taskName;
ct.taskDescription = al.taskDescription;
ct.taskType = TaskType.solveTask;
StartSubProcess ssp = new StartSubProcess();
ssp.startSolveProcess(ct);
}
}
}
* */
}
//如果分解的工作流为空。
if (MyWorkflowInstance.getdecomposeWorkflowApplications().Count == 0 && MyWorkflowInstance.getdecomposeVotingWorkflowApplications().Count==0)
{
//加载所有的需要解决的任务，作为解决任务发放出去
ArrayList li = crowdTaskService.getAllNeedSolvedCrowTaskInDecomposeResult1(crowdTask.mainTaskId);
foreach (DecomposeResult dr in li)
{
for (int k = 0; k < ConstantDefine.solvingNumber; k++)
{
//将这个任务分发出去
CrowdTask ct = new CrowdTask();
ct.taskName = dr.taskName;
ct.taskDescription = dr.taskDescription;
ct.taskType = TaskType.solveTask;
ct.taskParentWorkflowId = dr.parent_workflow_id;
StartSubProcess ssp = new StartSubProcess();
ssp.startSolveProcess(ct);
}
}
MyWorkflowInstance.getWorkflowApplication(crowdTask.mainTaskId).ResumeBookmark(BookmarkName.Decomposing,null); ;
}
}
void SubDivideWorkflowCompleted(WorkflowApplicationCompletedEventArgs e)
{
//流程结束，将流程实例移除
MyWorkflowInstance.removeDecomposeWorkflowApplication(e.InstanceId.ToString());
CrowdTaskService crowdTaskService = new CrowdTaskService();
//将当前流程的分解解决方案写入数据库
int result = crowdTaskService.saveDecomposeResult(e.InstanceId.ToString(), (ArrayList)e.Outputs["out_arraylist_task"]);
//得到当前分解任务的内容
CrowdTask crowdTask = new CrowdTask();
crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(e.InstanceId.ToString());
//通过当前分解任务的父工作流ID ，获得该父工作流的所有子工作流，如果都完成了则开启分解判断过程
ArrayList allSonCrowdTask = crowdTaskService.findAllSonCrowdTaskByParentWorkflowIdAndTaskName(crowdTask.taskParentWorkflowId, crowdTask.taskName, crowdTask.mainTaskId);
Dictionary <string, ArrayList> solutionTasks = new Dictionary <string, ArrayList>();
int count = 0;
//遍历看看这个任务的同一级的分解任务是否都结束了
foreach (CrowdTask ct in allSonCrowdTask)
{
WorkflowApplication wa = MyWorkflowInstance.getDecomposeWorkflowApplication(ct.taskWorkflowId);
if (wa != null)
{
break;
}
else
{
count++;
}
}
//如果都结束了
if (count == ConstantDefine.divideNumber)
{
//获得每一个分解任务给出的解决方案
foreach (CrowdTask ct in allSonCrowdTask)
{
ArrayList solutions = crowdTaskService.findDecomposeResultByWorkflowId(ct.taskWorkflowId, ct.mainTaskId);
if (solutions.Count != 0)
{
//表示当前工作流Id给出了分解方案
solutionTasks.Add(ct.taskWorkflowId, solutions);
}
}
//表示至少有一个分解任务给出了解决方案
if (solutionTasks.Count != 0)
{
//开启5个投票流程 工作流实例
for (int i = 0; i < ConstantDefine.decomposeVotingNumber; i++)
{
StartSubProcess ssp = new StartSubProcess();
ssp.startDevideVotingProcess(solutionTasks);
}
}
//表示所有的当前这几个分解任务都认为这个任务是简单任务，设置简单标记
else
{
//当前一个任务判定为简单，是要等这一层级的所有任务都判定完了在根据情况，把这一层是简单的任务抛出去
foreach (CrowdTask ct in allSonCrowdTask)
{
int h = crowdTaskService.updateDecomposeResultByWokflowIdAndTaskName(ct.taskParentWorkflowId, ct.taskName, ct.mainTaskId);
}
}
/*
* //等待这一层的所有任务都分解完成了，把这一层的简单任务选出来，分发出去
* ArrayList ThisLayerAllSonCrowdTask = crowdTaskService.findCrowdTaskByParentWorkflowIdAndTaskType(crowdTask.taskParentWorkflowId, TaskType.decomposeTask);
* int count1 = 0;
* //遍历这一层的任务，看看是否都完成了
* foreach (CrowdTask ct in ThisLayerAllSonCrowdTask)
* {
* WorkflowApplication wa = MyWorkflowInstance.getDecomposeWorkflowApplication(ct.taskWorkflowId);
* if (wa != null)
* {
* break;
* }
* else
* {
* count1++;
* }
* }
* //这一层的所有任务都完成了
* if (ThisLayerAllSonCrowdTask.Count == count1)
* {
* ArrayList al_simple = crowdTaskService.getAllThisLayerNeedSolvedCrowTaskInDecomposeResult(crowdTask.taskParentWorkflowId);
* //可以得到这一层一共有多少个简单任务
* //将每一个简单任务分发出去启动解决流程
* foreach (DecomposeResult al in al_simple)
* {
* for (int k = 0; k < ConstantDefine.solvingNumber; k++)
* {
* //将这个任务分发出去
* CrowdTask ct = new CrowdTask();
* ct.taskName = al.taskName;
* ct.taskDescription = al.taskDescription;
* ct.taskType = TaskType.solveTask;
* StartSubProcess ssp = new StartSubProcess();
* ssp.startSolveProcess(ct);
* }
* }
* }
* */
}
//如果分解的工作流为空。
if (MyWorkflowInstance.getdecomposeWorkflowApplications().Count == 0 && MyWorkflowInstance.getdecomposeVotingWorkflowApplications().Count == 0)
{
//加载所有的需要解决的任务，作为解决任务发放出去
ArrayList li = crowdTaskService.getAllNeedSolvedCrowTaskInDecomposeResult1(crowdTask.mainTaskId);
foreach (DecomposeResult dr in li)
{
for (int k = 0; k < ConstantDefine.solvingNumber; k++)
{
//将这个任务分发出去
CrowdTask ct = new CrowdTask();
ct.taskName = dr.taskName;
ct.taskDescription = dr.taskDescription;
ct.taskType = TaskType.solveTask;
ct.taskParentWorkflowId = dr.parent_workflow_id;
StartSubProcess ssp = new StartSubProcess();
ssp.startSolveProcess(ct);
}
}
MyWorkflowInstance.getWorkflowApplication(crowdTask.mainTaskId).ResumeBookmark(BookmarkName.Decomposing, null);;
}
}
protected void Page_Load(object sender, EventArgs e)
{
//根据传过来的工作流ID，加载对应的实例
crowdTaskService = new CrowdTaskService();
taskParentWorkflowId = Request.Params["parentWorkflowId"];
taskWorkflowId = Request.Params["taskWorkflowId"];
//得到需要分解任务实例
CrowdTask crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(taskWorkflowId);
TextBox1.Text = crowdTask.taskName;
TextBox2.Text = crowdTask.taskDescription;
TextBox3.Text = crowdTask.taskWorkflowId;
//根据当前投票任务的名字，来查找分解任务有哪些，在根据这些分解任务的ID，去decomposeResult 里面查找对应的结果
list = crowdTaskService.findAllSonCrowdTaskByParentTaskNameAndTaskDescriptionAndTaskType(crowdTask.taskName, crowdTask.taskDescription, TaskType.decomposeTask, crowdTask.mainTaskId);
foreach (CrowdTask ct in list)
{
ArrayList decomposeResult = crowdTaskService.findDecomposeResultByWorkflowId(ct.taskWorkflowId, crowdTask.mainTaskId);
//创建显示分解结果的表格
Table table = new Table();
table.BorderWidth = 1;
TableHeaderRow tableHeaderRow = new TableHeaderRow();
TableHeaderCell tableHeaderCell1 = new TableHeaderCell();
tableHeaderCell1.Text = "工作流ID：";
TableHeaderCell tableHeaderCell2 = new TableHeaderCell();
tableHeaderCell2.Text = ct.taskWorkflowId;
TableHeaderCell tableHeaderCell3 = new TableHeaderCell();
RadioButton radioButton = new RadioButton();
radioButton.GroupName = "vote";
radioButton.ID = ct.taskWorkflowId;
tableHeaderCell3.Controls.Add(radioButton);
tableHeaderRow.Cells.Add(tableHeaderCell1);
tableHeaderRow.Cells.Add(tableHeaderCell2);
tableHeaderRow.Cells.Add(tableHeaderCell3);
foreach (DecomposeResult dr in decomposeResult)
{
if (dr != null)
{
table.Rows.Add(tableHeaderRow);
}
}
foreach (DecomposeResult dr in decomposeResult)
{
TableRow tr = new TableRow();
TableCell tc = new TableCell();
tc.Text = dr.taskOrder;
TableCell tc1 = new TableCell();
tc1.Text = dr.taskName;
TableCell tc2 = new TableCell();
tc2.Text = dr.taskDescription;
tr.Cells.Add(tc);
tr.Cells.Add(tc1);
tr.Cells.Add(tc2);
table.Rows.Add(tr);
}
panel.Controls.Add(table);
}
}
void solveWorkflowCompleted(WorkflowApplicationCompletedEventArgs e)
{
MyWorkflowInstance.removeSolveWorkflowApplication(e.InstanceId.ToString());
CrowdTask crowdTask = new CrowdTask();
CrowdTaskService crowdTaskService = new CrowdTaskService();
crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(e.InstanceId.ToString());
//将当前流程的解决结果写入数据库
int result = crowdTaskService.saveSolveResult(crowdTask, (string)e.Outputs["out_solution"]);
/*
*
* //通过当前解决任务的工作流ID ，获得该工作流的所有同一任务的不同工作流，如果都完成了则开启解决判断过程;
* int count = 0;
*
* ArrayList allSonCrowdTask = crowdTaskService.findAllSonCrowdTaskByParentTaskNameAndTaskDescriptionAndTaskType(crowdTask.taskName, crowdTask.taskDescription,crowdTask.taskType);
*
* foreach (CrowdTask ct in allSonCrowdTask)
* {
* WorkflowApplication wa = MyWorkflowInstance.getSolveWorkflowApplication(ct.taskWorkflowId);
* if (wa != null)
* {
* break;
* }
* else
* {
* count++;
* }
* }
* if (count == ConstantDefine.solvingNumber)
* {
* //都已经解决完成，可以开始投票了
* //通过当前获得到的workflowId ,加载解决方案，然后保存在一个list里面，开启投票流程
*
* Dictionary<string,SolveResult> solveResutDic = new Dictionary<string,SolveResult>();
*
* //得到所有的解决结果
* foreach (CrowdTask ct in allSonCrowdTask)
* {
* SolveResult sr = crowdTaskService.findSolveResultByWorkflowId(ct.taskWorkflowId);
*
* solveResutDic.Add(ct.taskWorkflowId,sr);
* }
* if(solveResutDic.Count!=0)
* {
* //开启5个解决投票流程 工作流实例
* for (int i = 0; i < ConstantDefine.solveVotingNumber; i++)
* {
* StartSubProcess ssp = new StartSubProcess();
* ssp.startSolveVoteProcess(solveResutDic);
* }
* }
*
* }
*/
//如果所有的解决任务完成了。开启投票
if (MyWorkflowInstance.getSolveWorkflowApplications().Count == 0)
{
ArrayList allSolveCompeletedCrowdTask = crowdTaskService.findAllSolveCompeletedCrowdTaskByMainTaskId(crowdTask.mainTaskId);
//得到所有的解决结果
foreach (SolveResult sr in allSolveCompeletedCrowdTask)
{
//开启投票过程
Dictionary <string, SolveResult> solveResutDic = new Dictionary <string, SolveResult>();
ArrayList abc = crowdTaskService.finSolveResultByMainTaskIdAndTaskName(crowdTask.mainTaskId, sr.taskName);
foreach (SolveResult sdr in abc)
{
solveResutDic.Add(sdr.taskWorkflowId, sdr);
}
if (solveResutDic.Count != 0)
{
//开启5个解决投票流程 工作流实例
for (int i = 0; i < ConstantDefine.solveVotingNumber; i++)
{
StartSubProcess ssp = new StartSubProcess();
ssp.startSolveVoteProcess(solveResutDic);
}
}
}
MyWorkflowInstance.getWorkflowApplication(crowdTask.mainTaskId).ResumeBookmark(BookmarkName.Solving, null);
}
}
protected void Page_Load(object sender, EventArgs e)
{
//根据传过来的工作流ID，加载对应的实例
crowdTaskService = new CrowdTaskService();
//taskParentWorkflowId = Request.Params["parentWorkflowId"];
taskWorkflowId = Request.Params["taskWorkflowId"];
//得到任务实例
CrowdTask crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(taskWorkflowId);
TextBox1.Text = crowdTask.taskName;
TextBox2.Text = crowdTask.taskDescription;
//通过解决任务实例得到解决任务的同几个实例
//不应该根据分解任务的个数来生成表格，应该根据分解结果的个数来生成表格
list = crowdTaskService.findAllSonCrowdTaskByParentTaskNameAndTaskDescriptionAndTaskType(crowdTask.taskName,crowdTask.taskDescription, TaskType.solveTask,crowdTask.mainTaskId);
foreach (CrowdTask ct in list)
{
SolveResult solveResult = crowdTaskService.findSolveResultByWorkflowId(ct.taskWorkflowId,crowdTask.mainTaskId);
//创建显示解决结果的表格
Table table = new Table();
table.BorderWidth = 1;
TableHeaderRow tableHeaderRow = new TableHeaderRow();
TableHeaderCell tableHeaderCell1 = new TableHeaderCell();
tableHeaderCell1.Text = "工作流ID：";
TableHeaderCell tableHeaderCell2 = new TableHeaderCell();
tableHeaderCell2.Text = ct.taskWorkflowId;
TableHeaderCell tableHeaderCell3 = new TableHeaderCell();
RadioButton radioButton = new RadioButton();
radioButton.GroupName = "vote";
radioButton.ID = ct.taskWorkflowId;
tableHeaderCell3.Controls.Add(radioButton);
tableHeaderRow.Cells.Add(tableHeaderCell1);
tableHeaderRow.Cells.Add(tableHeaderCell2);
tableHeaderRow.Cells.Add(tableHeaderCell3);
table.Rows.Add(tableHeaderRow);
TableRow tr = new TableRow();
TableCell tc = new TableCell();
tc.Text ="解决方案";
TableCell tc1 = new TableCell();
tc1.Text = solveResult.taskSolution;
tr.Cells.Add(tc);
tr.Cells.Add(tc1);
table.Rows.Add(tr);
panel.Controls.Add(table);
}
}
protected void Page_Load(object sender, EventArgs e)
{
/*
*
* 得到系统所有的工作流程实例，并且显示出来
*
*/
//加载主任务
//加载所有的主任务实例
Dictionary <string, WorkflowApplication> mainTaskinstances = MyWorkflowInstance.getWorkflowApplications();
int mainTaskCount = mainTaskinstances.Count;
//加载单个的主任务实例
ReadOnlyCollection <BookmarkInfo>[] mainTaskBookmarks = new ReadOnlyCollection <BookmarkInfo> [mainTaskCount];
WorkflowApplication[] mainTaskInstance = new WorkflowApplication[mainTaskCount];
string[] mainTaskBookmarkName = new string[mainTaskCount];
CrowdTask[] mainTasks = new CrowdTask[mainTaskCount];
int i = 0;
foreach (KeyValuePair <string, WorkflowApplication> kvp in mainTaskinstances)
{
//得到每个主任务实例的书签信息
mainTaskBookmarks[i] = kvp.Value.GetBookmarks();
mainTasks[i] = crowdTaskService.findCrowdTaskByWorkflowId(kvp.Value.Id.ToString());
int bookmarkCount = mainTaskBookmarks[i].Count;
if (bookmarkCount == 1)
{
mainTaskBookmarkName[i] = kvp.Value.GetBookmarks().First().BookmarkName;
}
else
{
mainTaskBookmarkName[i] = "end";
}
mainTaskInstance[i] = kvp.Value;
i++;
}
//创建显示主任务的表格
for (int j = 0; j < mainTaskCount; j++)
{
TableRow tr = new TableRow();
TableCell tc1 = new TableCell();
tc1.Text = "任务名：";
TableCell tc2 = new TableCell();
HyperLink hl = new HyperLink();
switch (mainTaskBookmarkName[j])
{
case BookmarkName.WaitJudgement:
hl.NavigateUrl = "waitJudgement.aspx?taskWorkflowId=" + mainTasks[j].taskWorkflowId;
break;
case BookmarkName.Decomposing:
hl.NavigateUrl = "decomposing.aspx?&taskWorkflowId=" + mainTasks[j].taskWorkflowId;
break;
case BookmarkName.Solving:
hl.NavigateUrl = "solving.aspx";
break;
case BookmarkName.SolveVoting:
hl.NavigateUrl = "solveVoting.aspx";
break;
case BookmarkName.Merging:
hl.NavigateUrl = "subMerging.aspx";
break;
}
hl.Text = mainTasks[j].taskName + " ( " + mainTaskBookmarkName[j] + " ) 工作流ID: " + mainTasks[j].taskWorkflowId;
tc2.Controls.Add(hl);
tr.Cells.Add(tc1);
tr.Cells.Add(tc2);
mainTaskTable.Rows.Add(tr);
}
//加载分解任务
Dictionary <string, WorkflowApplication> decomposeInstances = MyWorkflowInstance.getdecomposeWorkflowApplications();
int decomposeCount = decomposeInstances.Count;
WorkflowApplication[] decomposeInstance = new WorkflowApplication[decomposeCount];
ReadOnlyCollection <BookmarkInfo>[] decomposeBookmarks = new ReadOnlyCollection <BookmarkInfo> [decomposeCount];
string[] decomposeBookmarkName = new string[decomposeCount];
//需要分解的众包任务
CrowdTask[] decomposeTasks = new CrowdTask[decomposeCount];
i = 0;
foreach (KeyValuePair <string, WorkflowApplication> kvp in decomposeInstances)
{
decomposeBookmarks[i] = kvp.Value.GetBookmarks();
decomposeTasks[i] = crowdTaskService.findCrowdTaskByWorkflowId(kvp.Key);
int bookmarkCount = decomposeBookmarks[i].Count;
if (bookmarkCount == 1)
{
decomposeBookmarkName[i] = kvp.Value.GetBookmarks().First().BookmarkName;
}
else
{
decomposeBookmarkName[i] = "end";
}
decomposeInstance[i] = kvp.Value;
i++;
}
//创建显示分解任务的表格
for (int j = 0; j < decomposeCount; j++)
{
TableRow tr = new TableRow();
TableCell tc1 = new TableCell();
tc1.Text = "任务名：";
TableCell tc2 = new TableCell();
HyperLink hl = new HyperLink();
switch (decomposeBookmarkName[j])
{
case BookmarkName.WaitJudgement:
hl.NavigateUrl = "subTaskJudgement.aspx?taskWorkflowId=" + decomposeTasks[j].taskWorkflowId;
break;
case BookmarkName.Decomposing:
hl.NavigateUrl = "subTaskDecomposing.aspx?taskWorkflowId=" + decomposeTasks[j].taskWorkflowId;
break;
}
hl.Text = decomposeTasks[j].taskName + " ( " + decomposeBookmarkName[j] + " ) 工作流ID: " + decomposeTasks[j].taskWorkflowId;
tc2.Controls.Add(hl);
tr.Cells.Add(tc1);
tr.Cells.Add(tc2);
decomposeTable.Rows.Add(tr);
}
//加载分解投票任务；
Dictionary <string, WorkflowApplication> decomposeVotingInstances = MyWorkflowInstance.getdecomposeVotingWorkflowApplications();
int decomposeVotingCount = decomposeVotingInstances.Count;
WorkflowApplication[] decomposeVotingInstance = new WorkflowApplication[decomposeVotingCount];
ReadOnlyCollection <BookmarkInfo>[] decomposeVotingBookmarks = new ReadOnlyCollection <BookmarkInfo> [decomposeVotingCount];
string[] decomposeVotingBookmarkName = new string[decomposeVotingCount];
//需要分解投票的众包任务
CrowdTask[] decomposeVotingTasks = new CrowdTask[decomposeVotingCount];
//父任务的问题投票
i = 0;
foreach (KeyValuePair <string, WorkflowApplication> kvp in decomposeVotingInstances)
{
decomposeVotingBookmarks[i] = kvp.Value.GetBookmarks();
decomposeVotingTasks[i] = crowdTaskService.findCrowdTaskByWorkflowId(kvp.Key);
int bookmarkCount = decomposeVotingBookmarks[i].Count;
if (bookmarkCount == 1)
{
decomposeVotingBookmarkName[i] = kvp.Value.GetBookmarks().First().BookmarkName;
}
else
{
decomposeVotingBookmarkName[i] = "end";
}
decomposeVotingInstance[i] = kvp.Value;
i++;
}
//创建分解投票问题的表格
for (int j = 0; j < decomposeVotingCount; j++)
{
TableRow tr = new TableRow();
TableCell tc1 = new TableCell();
tc1.Text = "任务名：";
TableCell tc2 = new TableCell();
HyperLink hl = new HyperLink();
// CrowdTask parentTask = crowdTaskService.findCrowdTaskByParentWorkflowIdAnd(decomposeVotingTasks[j].taskParentWorkflowId);
switch (decomposeVotingBookmarkName[j])
{
case BookmarkName.DecomposeVoting:
hl.NavigateUrl = "subTaskDecomposeVoting.aspx?taskWorkflowId=" + decomposeVotingInstance[j].Id.ToString() + "&parentWorkflowId=" + decomposeVotingTasks[j].taskParentWorkflowId;
break;
}
hl.Text = decomposeVotingTasks[j].taskName + " 的分解方案投票 ( " + decomposeVotingBookmarkName[j] + " ) ";
//hl.Text = "分解投票";
tc2.Controls.Add(hl);
tr.Cells.Add(tc1);
tr.Cells.Add(tc2);
decomposeVotingTable.Rows.Add(tr);
}
//加载解决任务；
Dictionary <string, WorkflowApplication> solveInstances = MyWorkflowInstance.getSolveWorkflowApplications();
int solveCount = solveInstances.Count;
WorkflowApplication[] solveInstance = new WorkflowApplication[solveCount];
ReadOnlyCollection <BookmarkInfo>[] solveBookmarks = new ReadOnlyCollection <BookmarkInfo> [solveCount];
string[] solveBookmarkName = new string[solveCount];
//需要解决的的众包任务
CrowdTask[] solveTasks = new CrowdTask[solveCount];
i = 0;
foreach (KeyValuePair <string, WorkflowApplication> kvp in solveInstances)
{
solveBookmarks[i] = kvp.Value.GetBookmarks();
solveTasks[i] = crowdTaskService.findCrowdTaskByWorkflowId(kvp.Key);
int bookmarkCount = solveBookmarks[i].Count;
if (bookmarkCount == 1)
{
solveBookmarkName[i] = kvp.Value.GetBookmarks().First().BookmarkName;
}
else
{
solveBookmarkName[i] = "end";
}
solveInstance[i] = kvp.Value;
i++;
}
//创建解决问题的表格
for (int j = 0; j < solveCount; j++)
{
TableRow tr = new TableRow();
TableCell tc1 = new TableCell();
tc1.Text = "任务名：";
TableCell tc2 = new TableCell();
HyperLink hl = new HyperLink();
//CrowdTask parentTask = crowdTaskService.findCrowdTaskByWorkflowId(solveTasks[j].taskParentWorkflowId);
switch (solveBookmarkName[j])
{
case BookmarkName.Solving:
hl.NavigateUrl = "subTaskSolving.aspx?taskWorkflowId=" + solveInstance[j].Id.ToString();
break;
default:
break;
}
hl.Text = solveTasks[j].taskName + " ( " + solveBookmarkName[j] + " ) ";
//hl.Text = "分解投票";
tc2.Controls.Add(hl);
tr.Cells.Add(tc1);
tr.Cells.Add(tc2);
solveTable.Rows.Add(tr);
}
//加载解决投票任务；
Dictionary <string, WorkflowApplication> solveVotingInstances = MyWorkflowInstance.getSolveVotingWorkflowApplications();
int solveVotingCount = solveVotingInstances.Count;
WorkflowApplication[] solveVotingInstance = new WorkflowApplication[solveVotingCount];
ReadOnlyCollection <BookmarkInfo>[] solveVotingBookmarks = new ReadOnlyCollection <BookmarkInfo> [solveVotingCount];
string[] solveVotingBookmarkName = new string[solveVotingCount];
//需要解决投票的众包任务
CrowdTask[] solveVotingTasks = new CrowdTask[solveVotingCount];
//需要解决的众包任务的投票投票
i = 0;
foreach (KeyValuePair <string, WorkflowApplication> kvp in solveVotingInstances)
{
solveVotingBookmarks[i] = kvp.Value.GetBookmarks();
solveVotingTasks[i] = crowdTaskService.findCrowdTaskByWorkflowId(kvp.Key);
int bookmarkCount = solveVotingBookmarks[i].Count;
if (bookmarkCount == 1)
{
solveVotingBookmarkName[i] = kvp.Value.GetBookmarks().First().BookmarkName;
}
else
{
solveVotingBookmarkName[i] = "end";
}
solveVotingInstance[i] = kvp.Value;
i++;
}
//创建分解投票问题的表格
for (int j = 0; j < solveVotingCount; j++)
{
TableRow tr = new TableRow();
TableCell tc1 = new TableCell();
tc1.Text = "任务名：";
TableCell tc2 = new TableCell();
HyperLink hl = new HyperLink();
// CrowdTask parentTask = crowdTaskService.findCrowdTaskByWorkflowId(decomposeVotingTasks[j].taskParentWorkflowId);
switch (solveVotingBookmarkName[j])
{
case BookmarkName.SolveVoting:
hl.NavigateUrl = "subTaskSolveVoting.aspx?taskWorkflowId=" + solveVotingInstance[j].Id.ToString();
break;
}
hl.Text = solveVotingTasks[j].taskName + " 的解决结果投票 ( " + solveVotingBookmarkName[j] + " ) ";
//hl.Text = "分解投票";
tc2.Controls.Add(hl);
tr.Cells.Add(tc1);
tr.Cells.Add(tc2);
solveVotingTable.Rows.Add(tr);
}
}
void DevideVotingWorkflowCompleted(WorkflowApplicationCompletedEventArgs e)
{
MyWorkflowInstance.removeVotingDecomposeWorkflowApplication(e.InstanceId.ToString());
CrowdTask crowdTask = new CrowdTask();
CrowdTaskService crowdTaskService = new CrowdTaskService();
//将当前流程的投票的分解的工作流ID写入数据库
int result = crowdTaskService.saveDecomposeVoteResult(e.InstanceId.ToString(), (string)e.Outputs["out_bestSolutionWorkflowId"]);
crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(e.InstanceId.ToString());
//通过当前任务的父工作流ID ，获得该父工作流的所有子工作流，如果都完成了则开启分解判断过程
int count = 0;
ArrayList allSonCrowdTask = crowdTaskService.findCrowdTaskByParentWorkflowIdAndTaskTypeAndTaskName(crowdTask.taskParentWorkflowId, crowdTask.taskName, TaskType.decomposeVotingTask, crowdTask.mainTaskId);
// Dictionary<string, ArrayList> solutionTasks = new Dictionary<string, ArrayList>();
// Dictionary<string, int> dic=null;
foreach (CrowdTask ct in allSonCrowdTask)
{
WorkflowApplication wa = MyWorkflowInstance.getDecomposeVotingWorkflowApplication(ct.taskWorkflowId);
if (wa != null)
{
//有一个不为空就表示改父工作流的所有子工作流没有都完成
break;
}
else
{
//表示完成了
count++;
}
}
if (count == ConstantDefine.decomposeVotingNumber)
{
//得到这个投票任务的结果
ArrayList arraylist1 = crowdTaskService.findCrowdTaskByParentWorkflowIdAndTaskTypeAndTaskName(crowdTask.taskParentWorkflowId, crowdTask.taskName, TaskType.decomposeTask, crowdTask.mainTaskId);
//将arrayList1里面的每个任务取出来，将其ID获得，然后根据ID去decomposeResult 里面取值
int[] nums = new int[ConstantDefine.divideNumber];
string[] votedId = new string[ConstantDefine.divideNumber];
int i = 0;
foreach (CrowdTask ct in arraylist1)
{
//在这里将去检索数据库
Dictionary <string, int> dict = crowdTaskService.findSupportThisIdNumber(ct.taskWorkflowId);
if (dict.Count != 0)
{
nums[i] = dict.First().Value;
votedId[i] = dict.First().Key;
}
else
{
nums[i] = 0;
votedId[i] = "";
}
i++;
}
string bestSolutionWorkflowId = votedId[0];
int max = nums[0];
for (int t = 0; t < nums.Length; t++)
{
if (nums[t] > max)
{
max = nums[t];
bestSolutionWorkflowId = votedId[t];
}
}
ArrayList bestSolutionArrayList = crowdTaskService.findDecomposeResultByWorkflowId(bestSolutionWorkflowId, crowdTask.mainTaskId);
//设置投票标记
crowdTaskService.updateDecomposeResultVotedByWorkflowId(bestSolutionWorkflowId);
foreach (DecomposeResult dr in bestSolutionArrayList)
{
//开启5个投票流程 工作流实例
for (int m = 0; m < ConstantDefine.divideNumber; m++)
{
CrowdTask task = new CrowdTask();
task.taskName = dr.taskName;
task.taskDescription = dr.taskDescription;
task.taskParentWorkflowId = bestSolutionWorkflowId;
task.taskType = TaskType.decomposeTask;
StartSubProcess ssp = new StartSubProcess();
ssp.startSubDivideProcess(new Guid(bestSolutionWorkflowId), task);
}
}
}
}
public void startDevideVotingProcess(Dictionary<string, ArrayList> solutionTasks)
{
//创建输入参数
Dictionary<string, object> para = new Dictionary<string, object>();
para.Add("solutionTasks", solutionTasks);
//创建实例对象
WorkflowApplication currentWorkflowInstance = new WorkflowApplication(new decomposeVoting(), para);
//委托流程结束时候调用的方法
currentWorkflowInstance.Completed = new Action<WorkflowApplicationCompletedEventArgs>(DevideVotingWorkflowCompleted);
//启动实例
currentWorkflowInstance.Run();
CrowdTaskService crowdTaskService = new CrowdTaskService();
//分解任务
CrowdTask divideTask = crowdTaskService.findCrowdTaskByWorkflowId(solutionTasks.First().Key);
CrowdTask crowdTask = new CrowdTask();
crowdTask.taskName = divideTask.taskName;
crowdTask.taskDescription = divideTask.taskDescription;
crowdTask.taskType = TaskType.decomposeVotingTask;
crowdTask.taskWorkflowId = currentWorkflowInstance.Id.ToString();
crowdTask.taskParentWorkflowId = crowdTaskService.findCrowdTaskByWorkflowId(solutionTasks.Keys.First().ToString()).taskParentWorkflowId;
int result = crowdTaskService.insert(crowdTask);
//更新每个实例的主工作流Id
crowdTaskService.updateCrowdTaskMainTaskIdByWorkflowId(currentWorkflowInstance.Id.ToString());
if (result == 1)
{
//将当前实例加入到分解任务集合中
MyWorkflowInstance.setDecomposeVotingWorkflowApplication(currentWorkflowInstance.Id.ToString(), currentWorkflowInstance);
}
}
protected void Page_Load(object sender, EventArgs e)
{
//根据传过来的工作流ID，加载对应的实例
crowdTaskService = new CrowdTaskService();
taskParentWorkflowId = Request.Params["parentWorkflowId"];
taskWorkflowId = Request.Params["taskWorkflowId"];
//得到需要分解任务实例
CrowdTask crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(taskWorkflowId);
TextBox1.Text = crowdTask.taskName;
TextBox2.Text = crowdTask.taskDescription;
TextBox3.Text = crowdTask.taskWorkflowId;
//根据当前投票任务的名字，来查找分解任务有哪些，在根据这些分解任务的ID，去decomposeResult 里面查找对应的结果
list = crowdTaskService.findAllSonCrowdTaskByParentTaskNameAndTaskDescriptionAndTaskType(crowdTask.taskName, crowdTask.taskDescription, TaskType.decomposeTask,crowdTask.mainTaskId);
foreach (CrowdTask ct in list)
{
ArrayList decomposeResult = crowdTaskService.findDecomposeResultByWorkflowId(ct.taskWorkflowId,crowdTask.mainTaskId);
//创建显示分解结果的表格
Table table = new Table();
table.BorderWidth = 1;
TableHeaderRow tableHeaderRow = new TableHeaderRow();
TableHeaderCell tableHeaderCell1 = new TableHeaderCell();
tableHeaderCell1.Text = "工作流ID：";
TableHeaderCell tableHeaderCell2 = new TableHeaderCell();
tableHeaderCell2.Text = ct.taskWorkflowId;
TableHeaderCell tableHeaderCell3 = new TableHeaderCell();
RadioButton radioButton = new RadioButton();
radioButton.GroupName = "vote";
radioButton.ID = ct.taskWorkflowId;
tableHeaderCell3.Controls.Add(radioButton);
tableHeaderRow.Cells.Add(tableHeaderCell1);
tableHeaderRow.Cells.Add(tableHeaderCell2);
tableHeaderRow.Cells.Add(tableHeaderCell3);
foreach (DecomposeResult dr in decomposeResult)
{
if (dr != null)
{
table.Rows.Add(tableHeaderRow);
}
}
foreach(DecomposeResult dr in decomposeResult){
TableRow tr = new TableRow();
TableCell tc = new TableCell();
tc.Text = dr.taskOrder;
TableCell tc1 = new TableCell();
tc1.Text = dr.taskName;
TableCell tc2 = new TableCell();
tc2.Text = dr.taskDescription;
tr.Cells.Add(tc);
tr.Cells.Add(tc1);
tr.Cells.Add(tc2);
table.Rows.Add(tr);
}
panel.Controls.Add(table);
}
}
void DevideVotingWorkflowCompleted(WorkflowApplicationCompletedEventArgs e)
{
MyWorkflowInstance.removeVotingDecomposeWorkflowApplication(e.InstanceId.ToString());
CrowdTask crowdTask = new CrowdTask();
CrowdTaskService crowdTaskService = new CrowdTaskService();
//将当前流程的投票的分解的工作流ID写入数据库
int result = crowdTaskService.saveDecomposeVoteResult(e.InstanceId.ToString(), (string)e.Outputs["out_bestSolutionWorkflowId"]);
crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(e.InstanceId.ToString());
//通过当前任务的父工作流ID ，获得该父工作流的所有子工作流，如果都完成了则开启分解判断过程
int count = 0;
ArrayList allSonCrowdTask = crowdTaskService.findCrowdTaskByParentWorkflowIdAndTaskTypeAndTaskName(crowdTask.taskParentWorkflowId, crowdTask.taskName,TaskType.decomposeVotingTask,crowdTask.mainTaskId);
// Dictionary<string, ArrayList> solutionTasks = new Dictionary<string, ArrayList>();
// Dictionary<string, int> dic=null;
foreach (CrowdTask ct in allSonCrowdTask)
{
WorkflowApplication wa = MyWorkflowInstance.getDecomposeVotingWorkflowApplication(ct.taskWorkflowId);
if (wa != null)
{
//有一个不为空就表示改父工作流的所有子工作流没有都完成
break;
}
else
{
//表示完成了
count++;
}
}
if (count == ConstantDefine.decomposeVotingNumber)
{
//得到这个投票任务的结果
ArrayList arraylist1= crowdTaskService.findCrowdTaskByParentWorkflowIdAndTaskTypeAndTaskName(crowdTask.taskParentWorkflowId,crowdTask.taskName,TaskType.decomposeTask,crowdTask.mainTaskId);
//将arrayList1里面的每个任务取出来，将其ID获得，然后根据ID去decomposeResult 里面取值
int[] nums = new int[ConstantDefine.divideNumber];
string[] votedId = new string[ConstantDefine.divideNumber];
int i=0;
foreach ( CrowdTask ct in arraylist1)
{
//在这里将去检索数据库
Dictionary<string,int> dict = crowdTaskService.findSupportThisIdNumber(ct.taskWorkflowId);
if(dict.Count!=0){
nums[i] = dict.First().Value;
votedId[i] =dict.First().Key;
}
else
{
nums[i] = 0;
votedId[i] = "";
}
i++;
}
string bestSolutionWorkflowId = votedId[0];
int max = nums[0];
for (int t = 0; t < nums.Length; t++)
{
if (nums[t] > max)
{
max = nums[t];
bestSolutionWorkflowId = votedId[t];
}
}
ArrayList bestSolutionArrayList = crowdTaskService.findDecomposeResultByWorkflowId(bestSolutionWorkflowId,crowdTask.mainTaskId);
//设置投票标记
crowdTaskService.updateDecomposeResultVotedByWorkflowId(bestSolutionWorkflowId);
foreach(DecomposeResult dr in bestSolutionArrayList){
//开启5个投票流程 工作流实例
for (int m = 0; m < ConstantDefine.divideNumber; m++)
{
CrowdTask task = new CrowdTask();
task.taskName=dr.taskName;
task.taskDescription=dr.taskDescription;
task.taskParentWorkflowId=bestSolutionWorkflowId;
task.taskType=TaskType.decomposeTask;
StartSubProcess ssp = new StartSubProcess();
ssp.startSubDivideProcess(new Guid(bestSolutionWorkflowId),task);
}
}
}
}
private void solveVotingWorkflowCompleted(WorkflowApplicationCompletedEventArgs e)
{
//保存到解决投票表里面
MyWorkflowInstance.removeSolveVotingWorkflowApplication(e.InstanceId.ToString());
CrowdTask crowdTask = new CrowdTask();
CrowdTaskService crowdTaskService = new CrowdTaskService();
crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(e.InstanceId.ToString());
//将当前流程的投票的分解的工作流ID写入数据库
int result = crowdTaskService.saveSolveVoteResult1(e.InstanceId.ToString(), (string)e.Outputs["out_bestSolutionWorkflowId"]);
//如果所有的解决投票任务完成了。开启投票
if (MyWorkflowInstance.getSolveVotingWorkflowApplications().Count == 0)
{
//更新得到最佳答案；
ArrayList allSolveCompeletedCrowdTask = crowdTaskService.findAllSolveCompeletedCrowdTaskByMainTaskId(crowdTask.mainTaskId);
//得到每一个解决任务的名字，然后根据名字和描述再去加载解决任务的ID，得到ID之后再去判断是不是最佳答案
foreach (SolveResult sr in allSolveCompeletedCrowdTask)
{
ArrayList al = crowdTaskService.finSolveResultByMainTaskIdAndTaskName(crowdTask.mainTaskId,sr.taskName);
int[] supportedNumber = new int[ConstantDefine.solvingNumber];
string[] supportedWorkflowId = new string[ConstantDefine.solvingNumber];
int i = 0;
foreach (SolveResult item in al)
{
//拿到每一个ID 当做supportedId，去数据库里面比对
supportedNumber[i]= crowdTaskService.getSolveVoteResultBySupportedId(item.taskWorkflowId);
supportedWorkflowId[i] = item.taskWorkflowId;
i++;
}
int maxNumber = supportedNumber[0];
string maxWorkflowId = supportedWorkflowId[0];
for (int j = 0; j < al.Count; j++)
{
if (supportedNumber[j] > maxNumber)
{
maxNumber = supportedNumber[j];
maxWorkflowId = supportedWorkflowId[j];
}
}
//找到了最佳答案，更新。
crowdTaskService.updateSolveResultBestAnswer(maxWorkflowId);
}
//更新书签
MyWorkflowInstance.getWorkflowApplication(crowdTask.mainTaskId).ResumeBookmark(BookmarkName.SolveVoting, null);
//生成分解树。
crowdTaskService.writeDecomposeTree(crowdTask.mainTaskId);
}
}
void solveWorkflowCompleted(WorkflowApplicationCompletedEventArgs e)
{
MyWorkflowInstance.removeSolveWorkflowApplication(e.InstanceId.ToString());
CrowdTask crowdTask = new CrowdTask();
CrowdTaskService crowdTaskService = new CrowdTaskService();
crowdTask = crowdTaskService.findCrowdTaskByWorkflowId(e.InstanceId.ToString());
//将当前流程的解决结果写入数据库
int result = crowdTaskService.saveSolveResult(crowdTask, (string)e.Outputs["out_solution"]);
/*
//通过当前解决任务的工作流ID ，获得该工作流的所有同一任务的不同工作流，如果都完成了则开启解决判断过程;
int count = 0;
ArrayList allSonCrowdTask = crowdTaskService.findAllSonCrowdTaskByParentTaskNameAndTaskDescriptionAndTaskType(crowdTask.taskName, crowdTask.taskDescription,crowdTask.taskType);
foreach (CrowdTask ct in allSonCrowdTask)
{
WorkflowApplication wa = MyWorkflowInstance.getSolveWorkflowApplication(ct.taskWorkflowId);
if (wa != null)
{
break;
}
else
{
count++;
}
}
if (count == ConstantDefine.solvingNumber)
{
//都已经解决完成，可以开始投票了
//通过当前获得到的workflowId ,加载解决方案，然后保存在一个list里面，开启投票流程
Dictionary<string,SolveResult> solveResutDic = new Dictionary<string,SolveResult>();
//得到所有的解决结果
foreach (CrowdTask ct in allSonCrowdTask)
{
SolveResult sr = crowdTaskService.findSolveResultByWorkflowId(ct.taskWorkflowId);
solveResutDic.Add(ct.taskWorkflowId,sr);
}
if(solveResutDic.Count!=0)
{
//开启5个解决投票流程 工作流实例
for (int i = 0; i < ConstantDefine.solveVotingNumber; i++)
{
StartSubProcess ssp = new StartSubProcess();
ssp.startSolveVoteProcess(solveResutDic);
}
}
}
*/
//如果所有的解决任务完成了。开启投票
if (MyWorkflowInstance.getSolveWorkflowApplications().Count == 0)
{
ArrayList allSolveCompeletedCrowdTask = crowdTaskService.findAllSolveCompeletedCrowdTaskByMainTaskId(crowdTask.mainTaskId);
//得到所有的解决结果
foreach (SolveResult sr in allSolveCompeletedCrowdTask)
{
//开启投票过程
Dictionary<string, SolveResult> solveResutDic = new Dictionary<string, SolveResult>();
ArrayList abc = crowdTaskService.finSolveResultByMainTaskIdAndTaskName(crowdTask.mainTaskId, sr.taskName);
foreach (SolveResult sdr in abc)
{
solveResutDic.Add(sdr.taskWorkflowId, sdr);
}
if (solveResutDic.Count != 0)
{
//开启5个解决投票流程 工作流实例
for (int i = 0; i < ConstantDefine.solveVotingNumber; i++)
{
StartSubProcess ssp = new StartSubProcess();
ssp.startSolveVoteProcess(solveResutDic);
}
}
}
MyWorkflowInstance.getWorkflowApplication(crowdTask.mainTaskId).ResumeBookmark(BookmarkName.Solving,null);
}
}