/// <summary>
/// 撤销提交
/// </summary>
/// <param name="task">当前任务Dto</param>
/// <returns>业务操作结果</returns>
protected OperationResult ExecuteCallBack(FlowExecuteDto task)
{
OperationResult result = IsCallBack(task.TaskId);
if (result.ResultType != OperationResultType.Success)
{
return(new OperationResult(OperationResultType.ValidError, "任务在下级已经有处理，不能再撤销！"));
}
FlowTaskRepository.UnitOfWork.TransactionEnabled = true; //事务处理
var nextTask = (List <Guid>)result.Data;
foreach (var item in nextTask)
{
FlowTaskRepository.Delete(item);
}
//标记本任务为待处理
var currentTask = FlowTaskRepository.Entities.Where(c => c.Id == task.TaskId).Single();
CompletedTask(currentTask, 1, "", "");
var currentSiblingTask = GetSiblingTask(currentTask.FlowItemId, currentTask.StepId).Where(c => c.Status == 30).ToList();
foreach (var item in currentSiblingTask)
{
CompletedTask(item, 1, "", "他人已撤销的任务");
}
FlowTaskRepository.UnitOfWork.SaveChanges();
result = new OperationResult(OperationResultType.Success, "撤销成功！");
return(result);
}
/// <summary>
/// 根据指定流程 选择的流转步骤创建任务
/// </summary>
/// <param name="task">当前任务Dto</param>
/// <param name="stepId">当前步骤Id</param>
protected void CreatedNextTask(FlowExecuteDto task, short stepId)
{
foreach (var step in task.Steps)
{
//流转的下个步骤
var nextStep = FlowStepRepository.Entities.Single(p => p.StepId == step.Key && p.FlowDesignId == task.FlowId);
foreach (var user in step.Value)
{
var uid = user.Key;
var uname = user.Value;
GetReceiver(task.FlowId, ref uid, ref uname);
WorkFlowTask taskModel = new WorkFlowTask()
{
Id = CombHelper.NewComb(),
PrevId = task.TaskId,
FlowItemId = task.ItemId,
PrevStepId = stepId,
StepId = nextStep.StepId,
StepName = nextStep.StepName,
SenderId = task.SenderId,
SenderName = task.SenderName,
ReceiverId = uid,
ReceiverName = uname,
IsComment = nextStep.CountersignType == 0 ? false : true,
IsSeal = nextStep.CountersignType == 2 ? true : false,
IsArchive = nextStep.IsArchives,
StepDay = nextStep.SpecifiedDay,
Status = 1
};
FlowTaskRepository.Insert(taskModel);
}
}
}
/// <summary>
/// 办结任务
/// </summary>
/// <param name="task">当前任务Dto</param>
/// <returns>业务操作结果</returns>
protected OperationResult ExecuteCompleted(FlowExecuteDto task)
{
OperationResult re = new OperationResult(OperationResultType.NoChanged, "办结未做处理！");
var currentTask = FlowTaskRepository.Entities.SingleOrDefault(c => c.Id == task.TaskId);
if (currentTask != null)
{
var currentItem = FlowItemRepository.Entities.Single(c => c.Id == currentTask.FlowItemId);
currentItem.Status = 1;
currentItem.CompletedTime = DateTime.Now;
currentTask.Comment = task.Comment;
currentTask.TaskNote = task.Note;
currentTask.Status = 10;
currentTask.CompletedTime = DateTime.Now;
FlowTaskRepository.UnitOfWork.TransactionEnabled = true; //事务处理
if (currentTask.IsArchive)
{
FlowArchiveRepository.Insert(new WorkFlowArchive()
{
Id = CombHelper.NewComb(),
FlowItemId = currentTask.FlowItemId,
CreatorUserName = task.SenderName
});
}
FlowTaskRepository.Update(currentTask);
FlowItemRepository.Update(currentItem);
FlowTaskRepository.UnitOfWork.SaveChanges();
re = new OperationResult(OperationResultType.Success, "成功办结!");
}
return(re);
}
public ActionResult Backed(FlowExecuteDto dto)
{
var steps = new Dictionary <int, Dictionary <string, string> >();
if (!string.IsNullOrEmpty(Request.Params["stepCheck"]))
{
var stepsIds = Request.Params["stepCheck"].Split(',');
foreach (var stepId in stepsIds)
{
steps.Add(int.Parse(stepId), null);
}
}
dto.ExecuteType = ExecuteType.Back;
dto.SenderId = Operator.UserId;
dto.SenderName = Operator.NickName;
dto.Steps = steps;
if (steps == null)
{
return(Json(new OperationResult(OperationResultType.Error, "请指定退回人！")));
}
//推送
ExecTask();
return(Json(FlowContract.Execute(dto).ToAjaxResult(), JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 执行 流转任务
/// </summary>
/// <param name="taskDto">当前任务Dto</param>
/// <returns>业务操作结果</returns>
public OperationResult Execute(FlowExecuteDto taskDto)
{
OperationResult result = new OperationResult(OperationResultType.NoChanged);
switch (taskDto.ExecuteType)
{
case ExecuteType.Submit:
result = ExecuteSubmit(taskDto);
break;
case ExecuteType.Back:
result = ExecuteBack(taskDto);
break;
case ExecuteType.CallBack:
result = ExecuteCallBack(taskDto);
break;
case ExecuteType.Completed:
result = ExecuteCompleted(taskDto);
break;
default:
break;
}
return(result);
}
public ActionResult Execute(FlowExecuteDto dto)
{
var steps = new Dictionary <int, Dictionary <string, string> >();
if (!string.IsNullOrEmpty(Request.Params["stepCheck"]))
{
var stepsIds = Request.Params["stepCheck"].Split(',');
foreach (var stepId in stepsIds)
{
if (!string.IsNullOrEmpty(Request.Params["stepCheck_receive_Id_" + stepId]))
{
var userIds = Request.Params["stepCheck_receive_Id_" + stepId].Split(',');
var userNames = Request.Params["stepCheck_receive_Name_" + stepId].Split(',');
var userList = new Dictionary <string, string>();
for (int i = 0; i < userIds.Length; i++)
{
userList.Add(userIds[i], userNames[i]);
}
steps.Add(int.Parse(stepId), userList);
}
}
}
dto.ExecuteType = ExecuteType.Submit;
dto.SenderId = Operator.UserId;
dto.SenderName = Operator.NickName;
dto.Steps = steps;
if (steps == null)
{
return(Json(new OperationResult(OperationResultType.Error, "请指定发送人！").ToAjaxResult()));
}
//推送
ExecTask();
return(Json(FlowContract.Execute(dto).ToAjaxResult(), JsonRequestBehavior.AllowGet));
}
public ActionResult StartFlow(FlowExecuteDto dto)
{
dto.TaskId = Guid.Empty;
dto.ExecuteType = ExecuteType.Submit;
dto.SenderId = Operator.UserId;
dto.SenderName = Operator.NickName;
var re = FlowContract.Execute(dto);
//推送
ExecTask();
return(Json(re.ToAjaxResult(), JsonRequestBehavior.AllowGet));
}
public ActionResult CallBack(Guid TaskId)
{
FlowExecuteDto dto = new FlowExecuteDto()
{
TaskId = TaskId,
ExecuteType = ExecuteType.CallBack
};
//推送
ExecTask();
return(Json(FlowContract.Execute(dto).ToAjaxResult(), JsonRequestBehavior.AllowGet));
}
public ActionResult Completed(Guid TaskId)
{
FlowExecuteDto execut = new FlowExecuteDto()
{
TaskId = TaskId,
ExecuteType = ExecuteType.Completed,
SenderName = Operator.NickName
};
//推送
ExecTask();
return(Json(FlowContract.Execute(execut).ToAjaxResult(), JsonRequestBehavior.AllowGet));
}
public ActionResult ExecuteAudit(FlowProjectDto dto)
{
var Edto = new FlowExecuteDto()
{
FlowId = dto.FlowId,
TaskId = dto.TaskId,
ItemId = dto.ItemId,
ExecuteType = ExecuteType.Submit,
SenderId = Operator.UserId,
SenderName = Operator.NickName
};
//推送
ExecTask();
return(Json(Execute(Edto), JsonRequestBehavior.AllowGet));
}
/// <summary>
/// 创建第一个任务
/// </summary>
/// <param name="task">当前任务Dto</param>
/// <returns>业务操作结果</returns>
protected OperationResult CreateFirstTask(FlowExecuteDto task)
{
OperationResult re = CheckFlow(task.FlowId, task.EntityId);
if (re.ResultType == OperationResultType.Success)
{
var firstStep = FlowStepRepository.Entities.Where(c => c.FlowDesignId == task.FlowId && c.StepType == 0).Select(m => new { m.StepId, m.StepName }).SingleOrDefault(); //起始步骤
var flowItemId = CombHelper.NewComb();
var id = CombHelper.NewComb();
WorkFlowTask taskModel = new WorkFlowTask()
{
Id = id,
FlowItemId = flowItemId,
PrevStepId = -1,
StepId = firstStep.StepId,
StepName = firstStep.StepName,
SenderId = task.SenderId,
SenderName = task.SenderName,
ReceiverId = task.SenderId,
ReceiverName = task.SenderName,
CreatedTime = DateTime.Now,
IsComment = false,
IsSeal = false,
IsArchive = false,
Status = 1
};
var model = new WorkFlowItem()
{
Id = flowItemId,
FlowDesignId = task.FlowId,
EntityId = task.EntityId,
EntityName = task.Title,
CreatorUserId = task.SenderId,
CreatorUserName = task.SenderName,
//StepDay,DelayDay,HandleDay 用触发器保证数据正确性
Status = 0
};
model.Tasks.Add(taskModel);
FlowItemRepository.Insert(model);
re = new OperationResult(OperationResultType.Success, "流程启动成功！");
//re.Data = taskModel;
}
return(re);
}
/// <summary>
/// 退回任务
/// </summary>
/// <param name="task">当前任务Dto</param>
/// <returns>业务操作结果</returns>
protected OperationResult ExecuteBack(FlowExecuteDto task)
{
OperationResult re = new OperationResult(OperationResultType.NoChanged, "退回未处理！");
var currentTask = FlowTaskRepository.Entities.Single(c => c.Id == task.TaskId);
if (currentTask != null)
{
if (currentTask.Status != 1 && currentTask.Status != 2)
{
return(new OperationResult(OperationResultType.ValidError, "任务已经处理，不能进行退回！"));
}
var currentStep = FlowStepRepository.Entities.Where(c => c.FlowDesignId == task.FlowId && c.StepId == currentTask.StepId).Select(m => new { m.StepType, m.BackType, m.SpecifiedBackStep }).SingleOrDefault();
if (currentStep.StepType == 0)
{
return(new OperationResult(OperationResultType.ValidError, "流程的第一个步骤不能退回！"));
}
if (currentStep.BackType == 0)
{
return(new OperationResult(OperationResultType.ValidError, "当前步骤为不可退回步骤！"));
}
#region 退回处理
List <WorkFlowTask> backTasks = new List <WorkFlowTask>();
if (currentStep.BackType == 1) //退回到上一步
{
backTasks.AddRange(FlowTaskRepository.Entities.Where(c => c.Id == currentTask.PrevId).ToList());
}
else if (currentStep.BackType == 2) //退回到第一步
{
var firstTack = FlowTaskRepository.Entities.Where(c => c.PrevStepId == -1 && c.FlowItemId == currentTask.FlowItemId).OrderByDescending(c => c.CreatedTime).ToList()[0];
firstTack.PrevId = task.TaskId; //上一个任务Id
backTasks.Add(firstTack);
}
else //退回到指定步
{
var backStep = FlowStepRepository.Entities.Where(c => c.FlowDesignId == task.FlowId && c.StepName == currentStep.SpecifiedBackStep).Select(c => new { c.StepId }).Single();
if (backStep == null)
{
return(new OperationResult(OperationResultType.ValidError, "当前流程步骤配置有误,不能退回！"));
}
var backtask = GetSiblingTask(currentTask.FlowItemId, backStep.StepId).OrderByDescending(c => c.SenderId).ThenByDescending(c => c.CreatedTime).ToList();
string senderId = "";
foreach (var item in backtask) //移除同一步骤中相同的发送人的以前的任务
{
if (senderId == item.SenderId)
{
backtask.Remove(item);
}
senderId = item.SenderId;
}
backTasks.AddRange(backtask);
}
FlowTaskRepository.UnitOfWork.TransactionEnabled = true; //事务处理
foreach (var item in backTasks)
{
WorkFlowTask newTask = new WorkFlowTask();
newTask.Id = CombHelper.NewComb();
newTask.PrevId = item.PrevId;
newTask.FlowItemId = item.FlowItemId;
newTask.PrevStepId = item.PrevStepId;
newTask.StepId = item.StepId;
newTask.StepName = item.StepName;
newTask.SenderId = task.SenderId;
newTask.SenderName = task.SenderName;
newTask.ReceiverId = item.ReceiverId;
newTask.ReceiverName = item.ReceiverName;
newTask.OpenedTime = null;
newTask.CompletedTime = null;
newTask.IsComment = item.IsComment;
newTask.IsSeal = item.IsSeal;
newTask.IsArchive = item.IsArchive;
newTask.TaskNote = "退回的任务";
newTask.StepDay = item.StepDay;
newTask.DelayDay = 0;
newTask.Status = 1;
FlowTaskRepository.Insert(newTask);
}
CompletedTask(currentTask, 20, task.Comment);
CompletedOtherSiblingTask(currentTask, 40, "", "他人已退回");
FlowTaskRepository.UnitOfWork.SaveChanges();
re = new OperationResult(OperationResultType.Success, "退回成功！");
#endregion
}
else
{
re = new OperationResult(OperationResultType.ValidError, "您要退回的任务不存在！");
}
return(re);
}
/// <summary>
/// 提交任务
/// </summary>
/// <param name="task">当前任务Dto</param>
/// <returns>业务操作结果</returns>
protected OperationResult ExecuteSubmit(FlowExecuteDto task)
{
OperationResult re = new OperationResult(OperationResultType.Success, "处理成功!");
WorkFlowTask currentTask = FlowTaskRepository.Entities.SingleOrDefault(c => c.Id == task.TaskId);
if (currentTask == null)
{
return(CreateFirstTask(task));
}
var currentStep = FlowStepRepository.Entities.Where(c => c.FlowDesignId == task.FlowId && c.StepId == currentTask.StepId).
Select(m => new { m.StepType, m.CountersignStrategy, m.CountersignPer, m.BackType }).SingleOrDefault();
#region 新增下级任务
if (currentStep != null)
{
if (currentTask.Status == 1 || currentTask.Status == 2)
{
FlowTaskRepository.UnitOfWork.TransactionEnabled = true; //事务处理
bool createNextTask = true;
switch (currentStep.CountersignStrategy)
{
case 0: //所有步骤同意
int count = GetSiblingTask(currentTask.FlowItemId, currentTask.StepId).Where(c => c.Status < 10).Count();
if (count > 1)
{
createNextTask = false;
}
break;
case 1: //一人同意即可
CompletedOtherSiblingTask(currentTask, 30, "", "他人已处理此任务！");
break;
case 2: //比例同意即可
decimal percentage = currentStep.CountersignPer <= 0 ? 100 : currentStep.CountersignPer;
IQueryable <WorkFlowTask> TaskQueryable = GetSiblingTask(currentTask.FlowItemId, currentTask.StepId).Where(c => c.PrevId == currentTask.PrevId);
if (Math.Round((((decimal)(TaskQueryable.Where(p => p.Status == 10).Count() + 1) / (decimal)TaskQueryable.Where(p => p.Status <= 10).Count()) * 100), 2, MidpointRounding.AwayFromZero) < percentage)
{
createNextTask = false;
}
else
{
CompletedOtherSiblingTask(currentTask, 30, "", "他人已处理此任务！");
}
break;
}
if (createNextTask)
{
CreatedNextTask(task, currentTask.StepId);
}
CompletedTask(currentTask, 10, task.Comment);
FlowTaskRepository.UnitOfWork.SaveChanges();
//是否超期处理
}
else
{
return(new OperationResult(OperationResultType.ValidError, "当前步骤已经由他人处理！"));
}
}
else
{
re = new OperationResult(OperationResultType.ValidError, "找不到当前步骤！");
}
#endregion
return(re);
}
