Пример #1
0
        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);
            }
        }
        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);
            }
        } 
Пример #3
0
        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);
            }
        }
        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);

            }
        }