3163 lines
129 KiB
C#
3163 lines
129 KiB
C#
using ce.autofac.extension;
|
||
using Infrastructure;
|
||
using Infrastructure.Extensions;
|
||
using Infrastructure.Helpers;
|
||
using Microsoft.Extensions.Configuration;
|
||
using OpenAuth.App.Base;
|
||
using OpenAuth.App.BasicQueryService;
|
||
using OpenAuth.App.Config;
|
||
using OpenAuth.App.Interface;
|
||
using OpenAuth.App.Request;
|
||
using OpenAuth.Repository;
|
||
using OpenAuth.Repository.Core;
|
||
using OpenAuth.Repository.Domain;
|
||
using SqlSugar;
|
||
using System.Data;
|
||
using System.Linq;
|
||
using Newtonsoft.Json;
|
||
using OpenAuth.App.BaseApp.Jobs;
|
||
using System.Text;
|
||
using DocumentFormat.OpenXml.Spreadsheet;
|
||
using Infrastructure.Utilities;
|
||
using OpenAuth.App.BaseApp.Base;
|
||
using System.Diagnostics;
|
||
using NPOI.Util;
|
||
|
||
namespace OpenAuth.App
|
||
{
|
||
public partial class WFProcessApp : SqlSugarBaseApp<WFProcess, SugarDbContext>
|
||
{
|
||
ISqlSugarClient client;
|
||
UserManager userManager;
|
||
PositionManager positionManager;
|
||
IConfiguration _configuration;
|
||
OpenJobApp _job;
|
||
public WFProcessApp(SqlSugar.ISugarUnitOfWork<SugarDbContext> unitWork,
|
||
SqlSugar.ISimpleClient<WFProcess> repository,
|
||
IAuth auth,
|
||
UserManager userManager,
|
||
OpenJobApp job,
|
||
PositionManager positionManager,
|
||
IConfiguration _configuration
|
||
) : base(unitWork, repository, auth)
|
||
{
|
||
client = base.Repository.AsSugarClient();
|
||
this.userManager = userManager;
|
||
this.positionManager = positionManager;
|
||
this._configuration = _configuration;
|
||
_job = job;
|
||
}
|
||
|
||
#region 获取数据
|
||
/// <summary>
|
||
/// 获取流程列表
|
||
/// </summary>
|
||
/// <param name="pagination">分页参数</param>
|
||
/// <param name="searchParams">查询参数</param>
|
||
/// <returns></returns>
|
||
public async Task<PageInfo<List<WFProcess>>> GetPageList(PageReq pageReq, WFProcessSearchDto searchParams)
|
||
{
|
||
RefAsync<int> totalCount = 0;
|
||
|
||
var exp = Expressionable.Create<WFProcess>()
|
||
.AndIF(!string.IsNullOrEmpty(searchParams.Keyword), t => t.Title.Contains(searchParams.Keyword) || t.SchemeName.Contains(searchParams.Keyword))
|
||
.AndIF(!string.IsNullOrEmpty(searchParams.Code), t => t.SchemeCode == searchParams.Code)
|
||
.AndIF(searchParams.StartDate != null && searchParams.EndDate != null, t => t.CreateDate >= searchParams.StartDate && t.CreateDate <= searchParams.EndDate);
|
||
|
||
if (searchParams.Type == 3)
|
||
{
|
||
exp = exp.And(t => t.EnabledMark == 3);
|
||
}
|
||
else
|
||
{
|
||
exp = exp.And(t => t.EnabledMark == 1);
|
||
|
||
if (searchParams.Type == 1)
|
||
{
|
||
exp = exp.And(t => t.IsFinished == 1);
|
||
}
|
||
else
|
||
{
|
||
exp = exp.And(t => t.IsFinished == 0);
|
||
}
|
||
}
|
||
|
||
var list = await client.Queryable<WFProcess>()
|
||
.Where(exp.ToExpression())
|
||
.OrderByDescending(t => t.CreateDate)
|
||
.ToPageListAsync(pageReq.page, pageReq.limit, totalCount);
|
||
|
||
return new PageInfo<List<WFProcess>>
|
||
{
|
||
Items = list,
|
||
Total = totalCount
|
||
};
|
||
}
|
||
/// <summary>
|
||
/// 获取我的流程
|
||
/// </summary>
|
||
/// <param name="pagination">分页参数</param>
|
||
/// <param name="searchParams">查询参数</param>
|
||
/// <param name="type"> 1正常2草稿3作废</param>
|
||
/// <returns></returns>
|
||
public async Task<PageInfo<List<WFProcess>>> GetMyPageList(PageReq pageReq, WFProcessSearchDto searchParams, int type)
|
||
{
|
||
RefAsync<int> totalCount = 0;
|
||
|
||
var userId = _auth.GetUserId();
|
||
var expression = Expressionable.Create<WFProcess>();
|
||
expression = expression.And(t => t.CreateUserId == userId || t.UserId == userId);
|
||
|
||
if (type == 2)
|
||
{
|
||
expression = expression.And(t => t.EnabledMark == 2);
|
||
}
|
||
else
|
||
{
|
||
expression = expression.And(t => t.EnabledMark != 2);
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(searchParams.Keyword))
|
||
{
|
||
expression = expression.And(t => t.Title.Contains(searchParams.Keyword) || t.SchemeName.Contains(searchParams.Keyword));
|
||
}
|
||
if (!string.IsNullOrEmpty(searchParams.Code))
|
||
{
|
||
expression = expression.And(t => t.SchemeCode == searchParams.Code);
|
||
}
|
||
if (searchParams.StartDate != null && searchParams.EndDate != null)
|
||
{
|
||
expression = expression.And(t => t.CreateDate >= searchParams.StartDate && t.CreateDate <= searchParams.EndDate);
|
||
}
|
||
|
||
var list = await client.Queryable<WFProcess>()
|
||
.Where(expression.ToExpression())
|
||
.OrderByDescending(t => t.CreateDate)
|
||
.ToPageListAsync(pageReq.page, pageReq.limit, totalCount);
|
||
|
||
return new PageInfo<List<WFProcess>>
|
||
{
|
||
Items = list,
|
||
Total = totalCount
|
||
};
|
||
}
|
||
/// <summary>
|
||
/// 获取流程进程实体
|
||
/// </summary>
|
||
/// <param name="keyValue">主键</param>
|
||
/// <returns></returns>
|
||
public async Task<WFProcess> GetEntity(string keyValue)
|
||
{
|
||
return await base.Repository.GetByIdAsync(keyValue);
|
||
}
|
||
#endregion
|
||
|
||
#region 保存更新删除
|
||
/// <summary>
|
||
/// 删除流程进程实体
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
public async Task<bool> DeleteEntity(string processId)
|
||
{
|
||
return await base.Repository.DeleteByIdAsync(processId);
|
||
}
|
||
#endregion
|
||
|
||
#region 流程API
|
||
/// <summary>
|
||
/// 保存草稿
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
/// <param name="schemeCode">流程模板编码</param>
|
||
/// <param name="userId">创建人</param>
|
||
/// <param name="parentProcessId">父级流程进程主键</param>
|
||
/// <param name="parentNodeId">父级流程节点Id</param>
|
||
/// <param name="parentTaskId">父级任务id</param>
|
||
/// <param name="isChild">是否为子流程</param>
|
||
/// <param name="title">流程标题</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> SaveDraft(string processId, string schemeCode, string userId, string instanceInfo, string parentProcessId, string parentNodeId, string parentTaskId, int isChild, string title = "")
|
||
{
|
||
var flag = false;
|
||
|
||
var currentUser = _auth.GetCurrentUser().User;
|
||
|
||
// 判断当前流程进程是否有保存过
|
||
var processEntity = await GetEntity(processId);
|
||
if (processEntity == null)
|
||
{
|
||
// 创建草稿，已经存在不做处理
|
||
var schemeInfo = await client.Queryable<WFSchemeInfo>().FirstAsync(a => a.Code == schemeCode);
|
||
WFProcess wfProcessEntity = new WFProcess()
|
||
{
|
||
Id = processId,
|
||
SchemeCode = schemeCode,
|
||
SchemeId = schemeInfo.SchemeId,
|
||
SchemeName = schemeInfo.Name,
|
||
Title = title,
|
||
InstanceInfo = JsonConvert.DeserializeObject<WFInstanceInfo>(instanceInfo),
|
||
EnabledMark = 2,
|
||
IsAgain = 0,
|
||
IsFinished = 0,
|
||
IsChild = isChild,
|
||
IsStart = 0,
|
||
ParentNodeId = parentNodeId,
|
||
ParentProcessId = parentProcessId,
|
||
ParentTaskId = parentTaskId,
|
||
CreateUserId = currentUser.Id.ToString(),
|
||
CreateUserName = currentUser.Name,
|
||
CreateUserAccount = currentUser.Account,
|
||
UserId = currentUser.Id.ToString()
|
||
};
|
||
|
||
if (string.IsNullOrEmpty(title))
|
||
{
|
||
wfProcessEntity.Title = currentUser.Name + "-" + schemeInfo.Name;
|
||
}
|
||
|
||
wfProcessEntity.CreateDate = DateTime.Now;
|
||
wfProcessEntity.UserId = currentUser.Id.ToString();
|
||
flag = await base.Repository.InsertAsync(wfProcessEntity);
|
||
}
|
||
else if (!string.IsNullOrEmpty(title) && processEntity.Title != title)
|
||
{
|
||
processEntity.Title = title;
|
||
flag = await base.Repository.UpdateAsync(processEntity);
|
||
}
|
||
else
|
||
{
|
||
flag = true;
|
||
}
|
||
|
||
return new Response<bool>
|
||
{
|
||
Result = flag,
|
||
Message = flag == true ? "success" : "error"
|
||
};
|
||
}
|
||
/// <summary>
|
||
/// 保存草稿-新版用户查询
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
/// <param name="schemeCode">流程模板编码</param>
|
||
/// <param name="userId">创建人</param>
|
||
/// <param name="parentProcessId">父级流程进程主键</param>
|
||
/// <param name="parentNodeId">父级流程节点Id</param>
|
||
/// <param name="parentTaskId">父级任务id</param>
|
||
/// <param name="isChild">是否为子流程</param>
|
||
/// <param name="title">流程标题</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> SaveDraftWithUser(string processId, string schemeCode, string userName, string instanceInfo, string parentProcessId, string parentNodeId, string parentTaskId, int isChild, string title = "")
|
||
{
|
||
var flag = false;
|
||
var currentUser = await client.Queryable<SysUser>().FirstAsync(r => r.Name == userName)
|
||
?? new SysUser
|
||
{
|
||
Id = -1,
|
||
Account = Define.SYSTEM_USERNAME,
|
||
Name = "超级管理员",
|
||
};
|
||
|
||
// 判断当前流程进程是否有保存过
|
||
var processEntity = await GetEntity(processId);
|
||
if (processEntity == null)
|
||
{
|
||
// 创建草稿，已经存在不做处理
|
||
var schemeInfo = await client.Queryable<WFSchemeInfo>().FirstAsync(a => a.Code == schemeCode);
|
||
WFProcess wfProcessEntity = new WFProcess()
|
||
{
|
||
Id = processId,
|
||
SchemeCode = schemeCode,
|
||
SchemeId = schemeInfo.SchemeId,
|
||
SchemeName = schemeInfo.Name,
|
||
Title = title,
|
||
InstanceInfo = JsonConvert.DeserializeObject<WFInstanceInfo>(instanceInfo),
|
||
EnabledMark = 2,
|
||
IsAgain = 0,
|
||
IsFinished = 0,
|
||
IsChild = isChild,
|
||
IsStart = 0,
|
||
ParentNodeId = parentNodeId,
|
||
ParentProcessId = parentProcessId,
|
||
ParentTaskId = parentTaskId,
|
||
CreateUserId = currentUser?.Id.ToString(),
|
||
CreateUserName = currentUser?.Name,
|
||
CreateUserAccount = currentUser?.Account,
|
||
UserId = currentUser?.Id.ToString()
|
||
};
|
||
|
||
if (string.IsNullOrEmpty(title))
|
||
{
|
||
wfProcessEntity.Title = currentUser.Name + "-" + schemeInfo.Name;
|
||
}
|
||
|
||
wfProcessEntity.CreateDate = DateTime.Now;
|
||
wfProcessEntity.UserId = currentUser.Id.ToString();
|
||
flag = await base.Repository.InsertAsync(wfProcessEntity);
|
||
}
|
||
else if (!string.IsNullOrEmpty(title) && processEntity.Title != title)
|
||
{
|
||
processEntity.Title = title;
|
||
flag = await base.Repository.UpdateAsync(processEntity);
|
||
}
|
||
|
||
return new Response<bool>
|
||
{
|
||
Result = flag,
|
||
Message = flag == true ? "success" : "error"
|
||
};
|
||
}
|
||
|
||
/// <summary>
|
||
/// 删除草稿
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
public async Task<Response<bool>> DeleteDraft(string processId)
|
||
{
|
||
var flag = false;
|
||
var response = new Response<bool>();
|
||
|
||
var iWFEngine = await Bootstraper(string.Empty, processId, null);
|
||
|
||
var scriptResult = await ExecuteScript(processId, "deleteDraft", iWFEngine.CreateUser,
|
||
iWFEngine.WFScheme.DeleteDraftType,
|
||
iWFEngine.WFScheme.DeleteDraftDbCode,
|
||
iWFEngine.WFScheme.DeleteDraftDbSQL,
|
||
iWFEngine.WFScheme.DeleteDraftUrl,
|
||
iWFEngine.WFScheme.DeleteDraftIOCName);
|
||
|
||
if (scriptResult)
|
||
{
|
||
flag = await DeleteEntity(processId);
|
||
if (flag)
|
||
{
|
||
response.Result = true;
|
||
response.Message = "success";
|
||
}
|
||
else
|
||
{
|
||
response.Result = false;
|
||
response.Message = "脚本执行成功，但流程信息删除失败";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
response.Result = false;
|
||
response.Message = "error";
|
||
}
|
||
return response;
|
||
}
|
||
/// <summary>
|
||
/// 创建流程
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
/// <param name="schemeCode">流程模板编码</param>
|
||
/// <param name="userId">创建人</param>
|
||
/// <param name="nextUsers">下一个节点审核人</param>
|
||
/// <param name="title">流程标题</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> Create(string processId, string schemeCode, string userId, Dictionary<string, string> nextUsers, string InstanceInfo, string title = "")
|
||
{
|
||
var flag = false;
|
||
var userInfo = await GetUserInfo(userId);
|
||
var iWFEngine = await Bootstraper(schemeCode, processId, userInfo, nextUsers);
|
||
// 下一部需要执行的任务
|
||
var taskList = await iWFEngine.GetTask(iWFEngine.StartNode.Id);
|
||
//获取当前流程信息
|
||
var process = await GetEntity(processId);
|
||
// 处理任务并更新数据
|
||
List<WFTask> myTaskList;
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
|
||
var processEntity = GetWFProcessEntity(iWFEngine.Config.Params, title);
|
||
processEntity.InstanceInfo = JsonConvert.DeserializeObject<WFInstanceInfo>(InstanceInfo);
|
||
if (string.IsNullOrEmpty(processEntity.Title))
|
||
{
|
||
processEntity.Title = userInfo.Name + "-" + processEntity.SchemeName;
|
||
}
|
||
processEntity.CreateDate = DateTime.Now;
|
||
|
||
if (taskList.FindIndex(t => t.Type == 100) != -1)
|
||
{
|
||
processEntity.IsFinished = 1;
|
||
if (process != null && process.IsChild == 1)
|
||
{
|
||
WFTask ts = new WFTask();
|
||
await ChildrenEndTask(process.ParentProcessId, process.ParentNodeId, "", ts, "");
|
||
}
|
||
}
|
||
|
||
if (process != null && process.IsChild == 1)
|
||
{
|
||
var taskEntity = await client.Queryable<WFTask>().Where(a => a.Id == process.ParentTaskId).FirstAsync();
|
||
if (taskEntity != null)
|
||
{
|
||
taskEntity.State = 3;
|
||
if (taskEntity.Type == 7)
|
||
{
|
||
var currentUser = _auth.GetCurrentUser().User;
|
||
taskEntity.UserId = currentUser.Id.ToString();
|
||
taskEntity.UserName = currentUser.Name;
|
||
}
|
||
await uwo.WFTask.UpdateAsync(taskEntity);
|
||
}
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(schemeCode))
|
||
{
|
||
await uwo.WFProcess.InsertAsync(processEntity);
|
||
}
|
||
else
|
||
{
|
||
await uwo.WFProcess.UpdateAsync(processEntity);
|
||
}
|
||
|
||
myTaskList = await ExecuteWFTaskEntity(taskList, iWFEngine, processId, "create", "create");
|
||
foreach (var item in myTaskList)
|
||
{
|
||
if (item.Type == 7)
|
||
{
|
||
await uwo.WFTaskUser.InsertRangeAsync(item.WFTaskUser);
|
||
}
|
||
item.ProcessTitle = processEntity.Title;
|
||
await Add(item);
|
||
}
|
||
|
||
WFTaskLog wfTaskLogEntity = new WFTaskLog()
|
||
{
|
||
OperationCode = "create",
|
||
OperationName = "提交流程",
|
||
TaskType = 0,
|
||
IsLast = 1,
|
||
Des = "提交流程",
|
||
ProcessId = processId,
|
||
UnitId = iWFEngine.StartNode.Id,
|
||
UnitName = string.IsNullOrEmpty(iWFEngine.StartNode.Name) ? "开始节点" : iWFEngine.StartNode.Name
|
||
};
|
||
await AddLog(wfTaskLogEntity);
|
||
|
||
flag = uwo.Commit();
|
||
}
|
||
|
||
var respone = new Response<bool>();
|
||
|
||
if (flag)
|
||
{
|
||
var scriptResults = new List<bool>();
|
||
// 脚本执行
|
||
var scriptTaskList = myTaskList.FindAll(t => t.Type == 10);
|
||
foreach (var item in scriptTaskList)
|
||
{
|
||
var result = await ExecuteScript(item, "create", processId, "", "",iWFEngine.CreateUser, iWFEngine, null,"");
|
||
scriptResults.Add(result);
|
||
}
|
||
|
||
if (scriptResults.Contains(false))
|
||
{
|
||
respone.Result = false;
|
||
respone.Message = "流程信息存储成功，但脚本执行失败";
|
||
}
|
||
else
|
||
{
|
||
respone.Result = true;
|
||
respone.Message = "success";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
respone.Result = false;
|
||
respone.Message = "error";
|
||
}
|
||
return respone;
|
||
}
|
||
/// <summary>
|
||
/// 创建流程
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
/// <param name="schemeCode">流程模板编码</param>
|
||
/// <param name="userId">创建人</param>
|
||
/// <param name="nextUsers">下一个节点审核人</param>
|
||
/// <param name="title">流程标题</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> CreateWithUser(string processId, string schemeCode, string userName, Dictionary<string, string> nextUsers, string InstanceInfo, string title = "")
|
||
{
|
||
var flag = false;
|
||
//var userInfo = await client.Queryable<SysUser>().FirstAsync(r => r.Name == userName);
|
||
var userInfo = await client.Queryable<SysUser>().FirstAsync(r => r.Name == userName)
|
||
?? new SysUser
|
||
{
|
||
Id = -1,
|
||
Account = Define.SYSTEM_USERNAME,
|
||
Name = "超级管理员",
|
||
};
|
||
var iWFEngine = await BootstraperWithUser(schemeCode, processId, userInfo, nextUsers);
|
||
// 下一部需要执行的任务
|
||
var taskList = await iWFEngine.GetTask(iWFEngine.StartNode.Id);
|
||
//获取当前流程信息
|
||
var process = await GetEntity(processId);
|
||
// 处理任务并更新数据
|
||
List<WFTask> myTaskList;
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
|
||
var processEntity = GetWFProcessEntity(iWFEngine.Config.Params, title);
|
||
processEntity.InstanceInfo = JsonConvert.DeserializeObject<WFInstanceInfo>(InstanceInfo);
|
||
if (string.IsNullOrEmpty(processEntity.Title))
|
||
{
|
||
processEntity.Title = userInfo.Name + "-" + processEntity.SchemeName;
|
||
}
|
||
processEntity.CreateDate = DateTime.Now;
|
||
|
||
if (taskList.FindIndex(t => t.Type == 100) != -1)
|
||
{
|
||
processEntity.IsFinished = 1;
|
||
if (process != null && process.IsChild == 1)
|
||
{
|
||
WFTask ts = new WFTask();
|
||
await ChildrenEndTask(process.ParentProcessId, process.ParentNodeId, "", ts, "");
|
||
}
|
||
}
|
||
|
||
if (process != null && process.IsChild == 1)
|
||
{
|
||
var taskEntity = await client.Queryable<WFTask>().Where(a => a.Id == process.ParentTaskId).FirstAsync();
|
||
if (taskEntity != null)
|
||
{
|
||
taskEntity.State = 3;
|
||
if (taskEntity.Type == 7)
|
||
{
|
||
var currentUser = _auth.GetCurrentUser().User;
|
||
taskEntity.UserId = currentUser.Id.ToString();
|
||
taskEntity.UserName = currentUser.Name;
|
||
}
|
||
await uwo.WFTask.UpdateAsync(taskEntity);
|
||
}
|
||
}
|
||
|
||
if (!string.IsNullOrEmpty(schemeCode))
|
||
{
|
||
await uwo.WFProcess.InsertAsync(processEntity);
|
||
}
|
||
else
|
||
{
|
||
await uwo.WFProcess.UpdateAsync(processEntity);
|
||
}
|
||
|
||
myTaskList = await ExecuteWFTaskEntity(taskList, iWFEngine, processId, "create", "create");
|
||
foreach (var item in myTaskList)
|
||
{
|
||
if (item.Type == 7)
|
||
{
|
||
await uwo.WFTaskUser.InsertRangeAsync(item.WFTaskUser);
|
||
}
|
||
item.ProcessTitle = processEntity.Title;
|
||
await Add(item);
|
||
}
|
||
|
||
WFTaskLog wfTaskLogEntity = new WFTaskLog()
|
||
{
|
||
OperationCode = "create",
|
||
OperationName = "提交流程",
|
||
TaskType = 0,
|
||
IsLast = 1,
|
||
Des = "提交流程",
|
||
ProcessId = processId,
|
||
UnitId = iWFEngine.StartNode.Id,
|
||
UnitName = string.IsNullOrEmpty(iWFEngine.StartNode.Name) ? "开始节点" : iWFEngine.StartNode.Name
|
||
};
|
||
await AddLog(wfTaskLogEntity);
|
||
|
||
flag = uwo.Commit();
|
||
}
|
||
|
||
var respone = new Response<bool>();
|
||
|
||
if (flag)
|
||
{
|
||
var scriptResults = new List<bool>();
|
||
// 脚本执行
|
||
var scriptTaskList = myTaskList.FindAll(t => t.Type == 10);
|
||
foreach (var item in scriptTaskList)
|
||
{
|
||
var result = await ExecuteScript(item, "create", processId, "", "",iWFEngine.CreateUser, iWFEngine, null, "");
|
||
scriptResults.Add(result);
|
||
}
|
||
|
||
if (scriptResults.Contains(false))
|
||
{
|
||
respone.Result = false;
|
||
respone.Message = "流程信息存储成功，但脚本执行失败";
|
||
}
|
||
else
|
||
{
|
||
respone.Result = true;
|
||
respone.Message = "success";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
respone.Result = false;
|
||
respone.Message = "error";
|
||
}
|
||
return respone;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 重新创建流程
|
||
/// </summary>
|
||
/// <param name="processId">流程实例主键</param>
|
||
/// <param name="des">备注</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> CreateAgain(string processId, string des)
|
||
{
|
||
var flag = false;
|
||
|
||
var iWFEngine = await Bootstraper("", processId, null, null);
|
||
|
||
var unList = (List<WFTask>)await GetUnFinishTaskList(processId);
|
||
var taskEntity = unList.Find(t => t.State == 1 && t.UnitId == iWFEngine.StartNode.Id);
|
||
|
||
if (taskEntity == null)
|
||
{
|
||
throw (new Exception("找不到重新提交流程任务！"));
|
||
}
|
||
|
||
// 下一部需要执行的任务
|
||
var taskList = await iWFEngine.GetTask(iWFEngine.StartNode.Id);
|
||
|
||
// 处理任务并更新数据
|
||
|
||
List<WFTask> myTaskList;
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
await uwo.WFProcess.UpdateSetColumnsTrueAsync(a => new WFProcess() { IsCancel = 1, IsAgain = 0 }, a => a.Id == processId);
|
||
await uwo.WFTask.UpdateSetColumnsTrueAsync(a => new WFTask() { State = 3 }, a => a.Id == taskEntity.Id);
|
||
// 更新上一个流转过来的任务，提示他无法被撤销
|
||
await CloseTaskLogCancel(taskEntity.ProcessId, taskEntity.PrevTaskId);
|
||
|
||
myTaskList = await ExecuteWFTaskEntity(taskList, iWFEngine, processId, taskEntity.Token, taskEntity.Id);
|
||
foreach (var item in myTaskList)
|
||
{
|
||
if (item.Type == 7)
|
||
{
|
||
await uwo.WFTaskUser.InsertRangeAsync(item.WFTaskUser);
|
||
}
|
||
await Add(item);
|
||
}
|
||
|
||
await CreateTaskLog(taskEntity, "", "重新提交", des, "");
|
||
|
||
//await _imMsgIBLL.VirtualDeleteByContentId(taskEntity.Token); // 更新消息
|
||
|
||
flag = uwo.Commit();
|
||
}
|
||
|
||
|
||
var respone = new Response<bool>();
|
||
|
||
if (flag)
|
||
{
|
||
var scriptResults = new List<bool>();
|
||
// 脚本执行
|
||
var scriptTaskList = myTaskList.FindAll(t => t.Type == 10);
|
||
foreach (var item in scriptTaskList)
|
||
{
|
||
var result = await ExecuteScript(item, "createAgain", processId, "", "",iWFEngine.CreateUser, iWFEngine, null, "");
|
||
scriptResults.Add(result);
|
||
}
|
||
|
||
if (scriptResults.Contains(false))
|
||
{
|
||
respone.Result = false;
|
||
respone.Message = "流程信息存储成功，但脚本执行失败";
|
||
}
|
||
else
|
||
{
|
||
respone.Result = true;
|
||
respone.Message = "success";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
respone.Result = false;
|
||
respone.Message = "error";
|
||
}
|
||
return respone;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 撤销流程（只有在该流程未被处理的情况下）
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
public async Task<bool> RevokeFlow(string processId)
|
||
{
|
||
var iWFEngine = await Bootstraper(string.Empty, processId, null, null);
|
||
|
||
if (iWFEngine.Config.Params.IsStart != 1)
|
||
{
|
||
// 获取脚本任务
|
||
var scriptList = (List<WFTask>)await GetList(processId, 10, "create");
|
||
foreach (var item in scriptList)
|
||
{
|
||
await ExecuteRevokeScript(item.UnitId, item.UnitName, processId, iWFEngine.CreateUser, iWFEngine);
|
||
}
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
await uwo.WFTask.DeleteAsync(a => a.ProcessId == processId);
|
||
await uwo.WFTaskLog.DeleteAsync(a => a.ProcessId == processId);
|
||
await uwo.WFProcess.UpdateSetColumnsTrueAsync(a => new WFProcess { EnabledMark = 2 }, a => a.Id == processId);
|
||
|
||
uwo.Commit();
|
||
}
|
||
|
||
await ExecuteScript(processId, "RevokeFlow", iWFEngine.CreateUser,
|
||
iWFEngine.WFScheme.UndoType,
|
||
iWFEngine.WFScheme.UndoDbCode,
|
||
iWFEngine.WFScheme.UndoDbSQL,
|
||
iWFEngine.WFScheme.UndoUrl,
|
||
iWFEngine.WFScheme.UndoIOCName);
|
||
|
||
return true;
|
||
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 催办流程
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
public async Task<Response<bool>> UrgeFlow(string processId)
|
||
{
|
||
// var userInfo = await this.CurrentUser();
|
||
var iWFEngine = await Bootstraper(string.Empty, processId, null, null);
|
||
// 获取未完成的任务
|
||
var taskList = await GetUnFinishTaskList(processId);
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
|
||
foreach (var item in taskList)
|
||
{
|
||
if (item.Type == 1 || item.Type == 3 || item.Type == 5 || item.Type == 6 || item.Type == 7)
|
||
{
|
||
item.IsUrge = 1;
|
||
item.UrgeTime = DateTime.Now;
|
||
|
||
|
||
// 发送消息
|
||
var msg = $"【审核】【催办】{item.ProcessTitle},{item.UnitName}";
|
||
var userList = new List<string>();
|
||
// todo 单体任务处理
|
||
userList.Add(item.UserId);
|
||
var node = iWFEngine.GetNode(item.UnitId);
|
||
//await _imMsgIBLL.SendMsg("IMWF", userList, msg, node.MessageType, item.F_Token);
|
||
|
||
await uwo.WFTask.UpdateAsync(item);
|
||
}
|
||
}
|
||
|
||
//await wfProcessSerive.Update(new WFProcessEntity() { F_IsUrge = 1, F_Id = processId });
|
||
|
||
WFTaskLog wfTaskLogEntity = new WFTaskLog()
|
||
{
|
||
Des = "催办审核",
|
||
TaskType = 98,
|
||
ProcessId = processId,
|
||
UnitId = iWFEngine.StartNode.Id,
|
||
UnitName = string.IsNullOrEmpty(iWFEngine.StartNode.Name) ? "开始节点" : iWFEngine.StartNode.Name
|
||
};
|
||
|
||
wfTaskLogEntity.CreateDate = DateTime.Now;
|
||
wfTaskLogEntity.UserId = _auth.GetUserId();
|
||
wfTaskLogEntity.UserName = _auth.GetUserNickName();
|
||
wfTaskLogEntity.Id = Guid.NewGuid().ToString();
|
||
await uwo.WFTaskLog.InsertAsync(wfTaskLogEntity);
|
||
|
||
var flag = uwo.Commit();
|
||
return new Response<bool>
|
||
{
|
||
Result = flag,
|
||
Message = flag == true ? "success" : "error"
|
||
};
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 审批流程
|
||
/// </summary>
|
||
/// <param name="taskId">流程任务主键</param>
|
||
/// <param name="code">流程审批操作码agree 同意 disagree 不同意 lrtimeout 超时</param>
|
||
/// <param name="name">流程审批操名称</param>
|
||
/// <param name="des">审批意见</param>
|
||
/// <param name="nextUsers">下一节点指定审核人</param>
|
||
/// <param name="stampImg">盖章图片</param>
|
||
/// <param name="stampPassWord">盖章图片密码</param>
|
||
/// <param name="nextId">下一个审核节点</param>
|
||
public async Task AuditFlow(string taskId, string code, string name, string des, Dictionary<string, string> nextUsers, string stampImg, string stampPassWord, string nextId)
|
||
{
|
||
var taskEntiy = await client.Queryable<WFTask>().Where(a => a.Id == taskId).FirstAsync();
|
||
if (taskEntiy == null)
|
||
{
|
||
throw (new Exception("找不到对应流程任务！"));
|
||
}
|
||
else if (taskEntiy.State != 1)
|
||
{
|
||
if (taskEntiy.State == 3 || taskEntiy.State == 4)
|
||
{
|
||
throw (new Exception("该任务已完成！"));
|
||
}
|
||
else
|
||
{
|
||
throw (new Exception("该任务未被激活！"));
|
||
}
|
||
}
|
||
|
||
//后期改
|
||
stampImg = "";
|
||
//stampImg = await _wFStampIBLL.ToWfImg(stampImg, stampPassWord);
|
||
|
||
var iWFEngine = await Bootstraper("", taskEntiy.ProcessId, null, nextUsers);
|
||
|
||
// 1.判断任务类型 1 普通任务 5 会签任务
|
||
if (taskEntiy.Type == 1||taskEntiy.Type==7)
|
||
{
|
||
await AuditNode(iWFEngine, taskEntiy, code, name, des, stampImg, nextId);
|
||
}
|
||
else if (taskEntiy.Type == 5)
|
||
{
|
||
await AuditNodeByCountersign(iWFEngine, taskEntiy, code, name, des, stampImg);
|
||
}
|
||
else
|
||
{
|
||
throw (new Exception("该任务无法审核！"));
|
||
}
|
||
|
||
//await _imMsgIBLL.VirtualDeleteByContentId(taskEntiy.F_Token); // 更新消息
|
||
|
||
// 发送消息
|
||
var msg = $"【提醒】{iWFEngine.Config.Params.Title},{taskEntiy.UnitName}已被处理";
|
||
var userList = new List<string>();
|
||
userList.Add(iWFEngine.CreateUser.Id);
|
||
var node = iWFEngine.StartNode;
|
||
//await _imMsgIBLL.SendMsg("IMWF", userList, msg, node.MessageType, iWFEngine.Config.Params.ProcessId);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 批量审核（只有同意和不同意）
|
||
/// </summary>
|
||
/// <param name="code">操作码</param>
|
||
/// <param name="taskIdList">任务id串</param>
|
||
public async Task AuditFlows(string code, List<string> taskIdList)
|
||
{
|
||
foreach (var taskId in taskIdList)
|
||
{
|
||
string operationName = code == "agree" ? "同意" : "不同意";
|
||
await AuditFlow(taskId, code, operationName, "批量审核", null, "", "", "");
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 撤销审核
|
||
/// </summary>
|
||
/// <param name="processId"></param>
|
||
/// <param name="taskId">流程任务主键</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> RevokeAudit(string processId, string taskId)
|
||
{
|
||
var iWFEngine = await Bootstraper(string.Empty, processId, null, null);
|
||
WFTask taskEntity;
|
||
WFProcess processEntity;
|
||
if (string.IsNullOrEmpty(taskId))
|
||
{ //撤销重新提交任务
|
||
processEntity = await GetEntity(processId);
|
||
if (processEntity.IsCancel != 1)
|
||
{
|
||
throw (new Exception("当前流程无法撤销！"));
|
||
}
|
||
|
||
var myTaskList = (List<WFTask>)await GetLastTaskList(processId, iWFEngine.StartNode.Id);
|
||
taskEntity = myTaskList[0];
|
||
|
||
processEntity.IsAgain = 1;
|
||
processEntity.IsCancel = 0;
|
||
}
|
||
else
|
||
{
|
||
taskEntity = await client.Queryable<WFTask>().Where(a => a.Id == taskId).FirstAsync();
|
||
|
||
if (taskEntity.State == 1)
|
||
{
|
||
throw (new Exception("当前任务无法撤销！"));
|
||
}
|
||
|
||
var taskLogEntity = await GetLogEntity(taskId);
|
||
|
||
if (taskLogEntity == null || taskLogEntity.IsCancel != 1)
|
||
{
|
||
throw (new Exception("当前任务无法撤销！"));
|
||
}
|
||
processEntity = new WFProcess()
|
||
{
|
||
Id = processId
|
||
};
|
||
processEntity.IsFinished = 0;
|
||
processEntity.IsAgain = 0;
|
||
}
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
// 获取脚本任务
|
||
var scriptList = await GetList(processId, 10, taskEntity.Id);
|
||
foreach (var item in scriptList)
|
||
{
|
||
await ExecuteRevokeScript(item.UnitId, item.UnitName, processId, iWFEngine.CreateUser, iWFEngine);
|
||
// 删除脚本任务执行日志
|
||
await DeleteLogByTaskId(item.Id);
|
||
}
|
||
|
||
|
||
// 删除所有生成的任务
|
||
await Delete(processId, taskEntity.Id);
|
||
|
||
// 如果是加签审核的，关闭最早的任务
|
||
if (taskEntity.Type == 6)
|
||
{
|
||
var myTaskEntiy = await GetTaskEntity(taskEntity.FirstId); // 原始审核任务
|
||
myTaskEntiy.State = 5;
|
||
await uwo.WFTask.UpdateAsync(myTaskEntiy);
|
||
}
|
||
|
||
|
||
// 如果是撤销转移任务
|
||
if (taskEntity.State == 6)
|
||
{
|
||
// 删除转移任务
|
||
await DeleteByFirstId(taskEntity.Id);
|
||
}
|
||
|
||
|
||
// 删除所有生成的日志
|
||
await DeleteLog(processId, taskEntity.Id);
|
||
|
||
// 更新等待任务状态
|
||
await OpenTask(processId, taskEntity.UnitId, 21, taskEntity.Id);
|
||
|
||
taskEntity.State = 1;
|
||
await uwo.WFTask.UpdateAsync(taskEntity);
|
||
|
||
await uwo.Db.Updateable(processEntity)
|
||
.IgnoreColumns(ignoreAllNullColumns: true)
|
||
.ExecuteCommandAsync();
|
||
|
||
var flag = uwo.Commit();
|
||
return new Response<bool>
|
||
{
|
||
Result = flag,
|
||
Message = flag == true ? "success" : "error"
|
||
};
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 流程加签
|
||
/// </summary>
|
||
/// <param name="taskId">流程任务主键</param>
|
||
/// <param name="userId">加签人员</param>
|
||
/// <param name="des">加签说明</param>
|
||
public async Task<Response<bool>> SignFlow(string taskId, string userId, string des)
|
||
{
|
||
var taskEntiy = await GetTaskEntity(taskId);
|
||
if (taskEntiy == null)
|
||
{
|
||
throw (new Exception("找不到对应流程任务！"));
|
||
}
|
||
else if (taskEntiy.State != 1)
|
||
{
|
||
if (taskEntiy.State == 3 || taskEntiy.State == 4)
|
||
{
|
||
throw (new Exception("该任务已完成！"));
|
||
}
|
||
else
|
||
{
|
||
throw (new Exception("该任务未被激活！"));
|
||
}
|
||
}
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
|
||
// 更新任务状态
|
||
taskEntiy.State = 5;
|
||
await uwo.WFTask.UpdateAsync(taskEntiy);
|
||
|
||
// 更新上一个流转过来的任务，提示他无法被撤销
|
||
await CloseTaskLogCancel(taskEntiy.ProcessId, taskEntiy.PrevTaskId);
|
||
|
||
// 填写日志
|
||
await CreateTaskLog(taskEntiy, "sign", "加签", des, "");
|
||
|
||
if (taskEntiy.Type != 6)
|
||
{
|
||
taskEntiy.FirstId = taskEntiy.Id;
|
||
}
|
||
|
||
var userInfo = await uwo.User.GetByIdAsync(userId);
|
||
|
||
// 添加加签任务
|
||
taskEntiy.PrevTaskId = taskEntiy.Id;
|
||
//taskEntiy.UserCompanyId = userInfo.CompanyId;
|
||
//taskEntiy.UserDepartmentId = userInfo.DepartmentId;
|
||
taskEntiy.UserId = userInfo.Id.ToString();
|
||
taskEntiy.UserName = userInfo.Name;
|
||
taskEntiy.Type = 6;
|
||
taskEntiy.State = 1;
|
||
await uwo.WFTask.InsertAsync(taskEntiy);
|
||
|
||
var flag = uwo.Commit();
|
||
return new Response<bool>
|
||
{
|
||
Result = flag,
|
||
Message = flag == true ? "success" : "error"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 流程加签审核
|
||
/// </summary>
|
||
/// <param name="taskId">流程任务主键</param>
|
||
/// <param name="code">操作码</param>
|
||
/// <param name="name">流程审批操名称</param>
|
||
/// <param name="des">审批意见</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> SignAudit(string taskId, string code, string name, string des)
|
||
{
|
||
var taskEntiy = await GetTaskEntity(taskId);
|
||
if (taskEntiy == null)
|
||
{
|
||
throw (new Exception("找不到对应流程任务！"));
|
||
}
|
||
else if (taskEntiy.State != 1)
|
||
{
|
||
if (taskEntiy.State == 3 || taskEntiy.State == 4)
|
||
{
|
||
throw (new Exception("该任务已完成！"));
|
||
}
|
||
else
|
||
{
|
||
throw (new Exception("该任务未被激活！"));
|
||
}
|
||
}
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
var myTaskEntiy = await GetTaskEntity(taskEntiy.FirstId); // 原始审核任务
|
||
myTaskEntiy.IsLast = 0;
|
||
await uwo.WFTask.UpdateAsync(myTaskEntiy);
|
||
myTaskEntiy.State = 1;
|
||
myTaskEntiy.IsLast = 1;
|
||
await Add(myTaskEntiy);
|
||
|
||
// 更新任务状态
|
||
taskEntiy.State = 3;
|
||
if (taskEntiy.Type == 7)
|
||
{
|
||
var currentUser = _auth.GetCurrentUser().User;
|
||
taskEntiy.UserId = currentUser.Id.ToString();
|
||
taskEntiy.UserName = currentUser.Name;
|
||
}
|
||
await uwo.WFTask.UpdateAsync(taskEntiy);
|
||
|
||
// 填写日志
|
||
await CreateTaskLog(taskEntiy, code, name, des, "");
|
||
|
||
// 更新上一个流转过来的任务，提示他无法被撤销
|
||
await CloseTaskLogCancel(taskEntiy.ProcessId, taskEntiy.PrevTaskId);
|
||
|
||
var flag = uwo.Commit();
|
||
return new Response<bool>
|
||
{
|
||
Result = flag,
|
||
Message = flag == true ? "success" : "error"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 确认阅读
|
||
/// </summary>
|
||
/// <param name="taskId">流程任务主键</param>
|
||
public async Task<Response<bool>> ReadFlow(string taskId)
|
||
{
|
||
var taskEntiy = await GetTaskEntity(taskId);
|
||
if (taskEntiy == null)
|
||
{
|
||
throw (new Exception("找不到对应流程任务！"));
|
||
}
|
||
else if (taskEntiy.State == 1)
|
||
{
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
taskEntiy.State = 3;
|
||
await uwo.WFTask.UpdateAsync(taskEntiy);
|
||
|
||
WFTaskLog wfTaskLogEntity = new WFTaskLog()
|
||
{
|
||
TaskType = taskEntiy.Type,
|
||
ProcessId = taskEntiy.ProcessId,
|
||
UnitId = taskEntiy.UnitId,
|
||
UnitName = taskEntiy.UnitName,
|
||
IsAgree = taskEntiy.IsAgree,
|
||
OperationCode = "read",
|
||
OperationName = "已阅",
|
||
Token = taskEntiy.Token,
|
||
PrevUnitId = taskEntiy.PrevUnitId,
|
||
PrevUnitName = taskEntiy.PrevUnitName,
|
||
TaskId = taskEntiy.Id,
|
||
IsCancel = 0
|
||
};
|
||
await AddLog(wfTaskLogEntity);
|
||
|
||
var flag = uwo.Commit();
|
||
return new Response<bool>
|
||
{
|
||
Result = flag,
|
||
Message = flag == true ? "success" : "error"
|
||
};
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
return new Response<bool>
|
||
{
|
||
Result = false,
|
||
Message = "error"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 转移流程
|
||
/// </summary>
|
||
/// <param name="taskId">任务id</param>
|
||
/// <param name="userId">转移人用户id</param>
|
||
/// <param name="des">说明</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> TransferUser(string taskId, string userId, string des)
|
||
{
|
||
var taskEntiy = await GetTaskEntity(taskId);
|
||
if (taskEntiy == null)
|
||
{
|
||
throw (new Exception("找不到对应流程任务！"));
|
||
}
|
||
else if (taskEntiy.State == 1)
|
||
{
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
var userInfo = await uwo.User.GetByIdAsync(userId);
|
||
|
||
// 更新任务状态
|
||
taskEntiy.State = 6;
|
||
await uwo.WFTask.UpdateAsync(taskEntiy);
|
||
|
||
// 更新流程
|
||
WFProcess processEntity = new WFProcess()
|
||
{
|
||
Id = taskEntiy.ProcessId,
|
||
IsStart = 1,
|
||
IsCancel = 0,
|
||
};
|
||
await uwo.WFProcess.UpdateAsync(processEntity);
|
||
|
||
// 填写日志
|
||
await CreateTaskLog(taskEntiy, "transfer", "转移", des, "");
|
||
|
||
// 更新上一个流转过来的任务，提示他无法被撤销
|
||
await CloseTaskLogCancel(taskEntiy.ProcessId, taskEntiy.PrevTaskId);
|
||
|
||
// 新建任务
|
||
var newTask = taskEntiy; //.ToJson().ToObject<WFTaskEntity>();
|
||
newTask.State = 1;
|
||
newTask.PrevTaskId = taskEntiy.Id;
|
||
//newTask.UserCompanyId = userInfo.F_CompanyId;
|
||
//newTask.UserDepartmentId = userInfo.F_DepartmentId;
|
||
newTask.UserId = userInfo.Id.ToString();
|
||
newTask.UserName = userInfo.Name;
|
||
|
||
await uwo.WFTask.InsertAsync(newTask);
|
||
|
||
// 发送消息
|
||
var iWFEngine = await Bootstraper("", taskEntiy.ProcessId, null);
|
||
var msg = $"【审核】{taskEntiy.ProcessTitle},{taskEntiy.UnitName}";
|
||
var userList = new List<string>();
|
||
userList.Add(userInfo.Id.ToString());
|
||
var node = iWFEngine.GetNode(taskEntiy.UnitId);
|
||
//await _imMsgIBLL.SendMsg("IMWF", userList, msg, node.MessageType, newTask.F_Token);
|
||
|
||
var flag = uwo.Commit();
|
||
|
||
return new Response<bool>
|
||
{
|
||
Result = flag,
|
||
Message = flag == true ? "success" : "error"
|
||
};
|
||
}
|
||
}
|
||
else
|
||
{
|
||
return new Response<bool>
|
||
{
|
||
Result = false,
|
||
Message = "error"
|
||
};
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取下一节点审核人
|
||
/// </summary>
|
||
/// <param name="code">流程模板编码</param>
|
||
/// <param name="processId">流程进程主键</param>
|
||
/// <param name="nodeId">流程节点Id</param>
|
||
/// <param name="operationCode">流程操作代码</param>
|
||
/// <param name="userId">创建人</param>
|
||
/// <returns></returns>
|
||
public async Task<Dictionary<string, List<WFUserInfo>>> GetNextAuditors(string code, string processId, string nodeId, string operationCode, string userId)
|
||
{
|
||
Dictionary<string, List<WFUserInfo>> res = new Dictionary<string, List<WFUserInfo>>();
|
||
var userInfo = await client.Queryable<SysUser>().Where(a => a.Id.ToString() == userId).FirstAsync();
|
||
var iWFEngine = await Bootstraper(code, processId, userInfo);
|
||
|
||
// 下一部需要执行的任务
|
||
var taskList = await iWFEngine.GetTask(nodeId, operationCode);
|
||
|
||
foreach (var item in taskList)
|
||
{
|
||
if ((item.Type == 1 || item.Type == 3 || item.Type == 5||item.Type==7) && item.User.IsNew)
|
||
{
|
||
if (!res.ContainsKey(item.UnitId))
|
||
{
|
||
res.Add(item.UnitId, new List<WFUserInfo>());
|
||
}
|
||
res[item.UnitId].Add(item.User);
|
||
}
|
||
}
|
||
|
||
return res;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 作废流程
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> DeleteProcess(string processId)
|
||
{
|
||
var flag = false;
|
||
var iWFEngine = await Bootstraper(string.Empty, processId, null);
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
// 更新流程状态
|
||
WFProcess processEntity = new WFProcess()
|
||
{
|
||
Id = processId,
|
||
|
||
};
|
||
await uwo.WFProcess.UpdateSetColumnsTrueAsync(a => new WFProcess { EnabledMark = 3 }, a => a.Id == processId);
|
||
|
||
await uwo.WFTask.UpdateSetColumnsTrueAsync(a => new WFTask { State = 7 }, a => a.ProcessId == processId && a.State == 1);
|
||
flag = uwo.Commit();
|
||
}
|
||
|
||
var response = new Response<bool>();
|
||
|
||
if (flag)
|
||
{
|
||
var scriptResult = await ExecuteScript(processId, "delete", iWFEngine.CreateUser,
|
||
iWFEngine.WFScheme.DeleteType,
|
||
iWFEngine.WFScheme.DeleteDbCode,
|
||
iWFEngine.WFScheme.DeleteDbSQL,
|
||
iWFEngine.WFScheme.DeleteUrl,
|
||
iWFEngine.WFScheme.DeleteIOCName);
|
||
|
||
if (scriptResult)
|
||
{
|
||
response.Result = true;
|
||
response.Message = "success";
|
||
}
|
||
else
|
||
{
|
||
response.Result = false;
|
||
response.Message = "流程状态更新成功，但脚本执行失败";
|
||
}
|
||
}
|
||
else
|
||
{
|
||
response.Result = false;
|
||
response.Message = "error";
|
||
}
|
||
return response;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 流程还原
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> RecoverProcess(string processId)
|
||
{
|
||
var flag = false;
|
||
var iWFEngine = await Bootstraper(string.Empty, processId, null);
|
||
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
// 更新流程状态
|
||
WFProcess processEntity = new WFProcess()
|
||
{
|
||
Id = processId,
|
||
|
||
};
|
||
await uwo.WFProcess.UpdateSetColumnsTrueAsync(a => new WFProcess { EnabledMark = 1 }, a => a.Id == processId);
|
||
|
||
await uwo.WFTask.UpdateSetColumnsTrueAsync(a => new WFTask { State = 1 }, a => a.ProcessId == processId && a.State == 7);
|
||
flag = uwo.Commit();
|
||
}
|
||
|
||
var response = new Response<bool>();
|
||
|
||
if (flag)
|
||
{
|
||
|
||
response.Result = true;
|
||
response.Message = "success";
|
||
}
|
||
else {
|
||
response.Result = false;
|
||
response.Message = "error";
|
||
}
|
||
|
||
return response;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 指派流程审核人
|
||
/// </summary>
|
||
/// <param name="processId">流程进程主键</param>
|
||
/// <param name="pointList">流程指派人信息</param>
|
||
/// <returns></returns>
|
||
public async Task<Response<bool>> PointUser(string processId, List<WFProcessPoint> pointList)
|
||
{
|
||
var list = await GetUnFinishTaskList(processId);
|
||
Dictionary<string, List<WFTask>> map = new Dictionary<string, List<WFTask>>();
|
||
foreach (var item in list)
|
||
{
|
||
if (!map.ContainsKey(item.UnitId))
|
||
{
|
||
map.Add(item.UnitId, new List<WFTask>());
|
||
}
|
||
map[item.UnitId].Add(item);
|
||
}
|
||
|
||
var addList = new List<WFTask>();
|
||
var iWFEngine = await Bootstraper("", processId, null);
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
|
||
foreach (var item in pointList)
|
||
{
|
||
if (map.ContainsKey(item.UnitId))
|
||
{
|
||
await CloseTask(processId, map[item.UnitId][0].Token, "");
|
||
var userIdList = item.UserIds.Split(",");
|
||
foreach (var userId in userIdList)
|
||
{
|
||
var addItem = Newtonsoft.Json.JsonConvert.SerializeObject(map[item.UnitId][0]).ToObject<WFTask>();
|
||
addItem.State = 1;
|
||
if (addItem.Type == 6)
|
||
{
|
||
addItem.Type = 1;
|
||
}
|
||
|
||
var userEntity = _auth.GetCurrentUser().User;
|
||
|
||
addItem.UserId = userId;
|
||
addItem.UserName = userEntity.Name;
|
||
//addItem.UserCompanyId = userEntity.F_CompanyId;
|
||
//addItem.UserDepartmentId = userEntity.F_DepartmentId;
|
||
|
||
// 发送消息
|
||
var msg = $"【审核】{addItem.ProcessTitle},{addItem.UnitName}";
|
||
var userList = new List<string>();
|
||
userList.Add(userId);
|
||
var node = iWFEngine.GetNode(addItem.UnitId);
|
||
//await _imMsgIBLL.SendMsg("IMWF", userList, msg, node.MessageType, addItem.F_Token);
|
||
|
||
addList.Add(addItem);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
throw (new Exception("找不到指派任务节点！"));
|
||
}
|
||
}
|
||
|
||
foreach (var item in addList)
|
||
{
|
||
await Add(item);
|
||
}
|
||
|
||
var flag = uwo.Commit();
|
||
|
||
return new Response<bool>()
|
||
{
|
||
Result = flag,
|
||
Message = flag == true ? "success" : "error"
|
||
};
|
||
}
|
||
|
||
}
|
||
#endregion
|
||
|
||
#region
|
||
/// <summary>
|
||
/// 流程模板初始化
|
||
/// </summary>
|
||
/// <param name="code">流程模板</param>
|
||
/// <param name="processId">流程实例</param>
|
||
/// <param name="userInfo">提交人用户信息</param>
|
||
/// <param name="nextUsers">下一个节点审核人</param>
|
||
/// <returns></returns>
|
||
private async Task<IWFEngine> Bootstraper(string code, string processId, SysUser userInfo, Dictionary<string, string> nextUsers = null)
|
||
{
|
||
|
||
WFEngineConfig wfEngineConfig = new WFEngineConfig();
|
||
WFParams wfParams = new WFParams();
|
||
wfEngineConfig.Params = wfParams;
|
||
|
||
var currentUser = _auth.GetCurrentUser().User;
|
||
wfParams.CurrentUser = new WFUserInfo()
|
||
{
|
||
Id = currentUser.Id.ToString(),
|
||
Account = currentUser.Account,
|
||
Name = currentUser.Name
|
||
//CompanyId = currentUser.F_CompanyId,
|
||
//DepartmentId = currentUser.F_DepartmentId
|
||
};
|
||
if (!string.IsNullOrEmpty(code))
|
||
{
|
||
var schemeInfo = await client.Queryable<WFSchemeInfo>().FirstAsync(a => a.Code == code);
|
||
if (schemeInfo != null)
|
||
{
|
||
var data = await client.Queryable<WFScheme>().FirstAsync(a => a.Id == schemeInfo.SchemeId);
|
||
if (data != null)
|
||
{
|
||
wfParams.Scheme = data.Content;
|
||
wfParams.SchemeCode = code;
|
||
wfParams.SchemeId = schemeInfo.SchemeId;
|
||
wfParams.SchemeName = schemeInfo.Name;
|
||
wfParams.ProcessId = processId;
|
||
wfParams.HasInstance = false;
|
||
|
||
wfParams.CreateUser = new WFUserInfo()
|
||
{
|
||
Id = userInfo.Id.ToString(),
|
||
Account = userInfo.Account,
|
||
Name = userInfo.Name
|
||
//CompanyId = userInfo.F_CompanyId,
|
||
//DepartmentId = userInfo.F_DepartmentId
|
||
};
|
||
}
|
||
else
|
||
{
|
||
throw new Exception(string.Format("无法获取对应的流程模板【{0}】", code));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
throw new Exception(string.Format("无法获取对应的流程模板【{0}】", code));
|
||
}
|
||
}
|
||
else if (!string.IsNullOrEmpty(processId))
|
||
{
|
||
var processEntity = await GetEntity(processId);
|
||
if (processEntity != null)
|
||
{
|
||
var data = await client.Queryable<WFScheme>().FirstAsync(a => a.Id == processEntity.SchemeId);
|
||
if (data != null)
|
||
{
|
||
wfParams.Scheme = data.Content;
|
||
wfParams.SchemeCode = processEntity.SchemeCode;
|
||
wfParams.SchemeId = processEntity.SchemeId;
|
||
wfParams.SchemeName = processEntity.SchemeName;
|
||
wfParams.IsChild = processEntity.IsChild == 1;
|
||
wfParams.ParentProcessId = processEntity.ParentProcessId;
|
||
wfParams.ParentTaskId = processEntity.ParentTaskId;
|
||
wfParams.ParentNodeId = processEntity.ParentNodeId;
|
||
wfParams.ProcessId = processId;
|
||
wfParams.HasInstance = true;
|
||
wfParams.IsStart = processEntity.IsStart == 1 ? 1 : 0;
|
||
wfParams.Title = processEntity.Title;
|
||
|
||
wfParams.CreateUser = new WFUserInfo()
|
||
{
|
||
Id = processEntity.CreateUserId,
|
||
Account = processEntity.CreateUserAccount,
|
||
Name = processEntity.CreateUserName,
|
||
CompanyId = processEntity.CreateUserCompanyId,
|
||
DepartmentId = processEntity.CreateUserDepartmentId
|
||
};
|
||
}
|
||
else
|
||
{
|
||
throw new Exception(string.Format("无法获取流程模板【{0}】", processEntity.SchemeId));
|
||
}
|
||
}
|
||
else if (string.IsNullOrEmpty(wfParams.Scheme))
|
||
{
|
||
throw new Exception(string.Format("无法获取实例数据【{0}】", processId));
|
||
}
|
||
}
|
||
|
||
|
||
wfParams.NextUsers = nextUsers;
|
||
|
||
|
||
// 注册委托方法
|
||
wfEngineConfig.GetAwaitTaskList = GetAwaitTaskList;
|
||
wfEngineConfig.GetUserList = GetUserList;
|
||
wfEngineConfig.GetSystemUserList = GetSystemUserList;
|
||
wfEngineConfig.GetPrevTaskUserList = GetPrevTaskUserList;
|
||
wfEngineConfig.IsCountersignAgree = IsCountersignAgree;
|
||
wfEngineConfig.GetPrevUnitId = GetPrevUnitId;
|
||
|
||
|
||
IWFEngine iwfEngine = new WFEngine(wfEngineConfig, client);
|
||
|
||
return iwfEngine;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 流程模板初始化
|
||
/// </summary>
|
||
/// <param name="code">流程模板</param>
|
||
/// <param name="processId">流程实例</param>
|
||
/// <param name="userInfo">提交人用户信息</param>
|
||
/// <param name="nextUsers">下一个节点审核人</param>
|
||
/// <returns></returns>
|
||
private async Task<IWFEngine> BootstraperWithUser(string code, string processId, SysUser userInfo, Dictionary<string, string> nextUsers = null)
|
||
{
|
||
|
||
WFEngineConfig wfEngineConfig = new WFEngineConfig();
|
||
WFParams wfParams = new WFParams();
|
||
wfEngineConfig.Params = wfParams;
|
||
|
||
var currentUser = userInfo;
|
||
wfParams.CurrentUser = new WFUserInfo()
|
||
{
|
||
Id = currentUser.Id.ToString(),
|
||
Account = currentUser.Account,
|
||
Name = currentUser.Name
|
||
//CompanyId = currentUser.F_CompanyId,
|
||
//DepartmentId = currentUser.F_DepartmentId
|
||
};
|
||
if (!string.IsNullOrEmpty(code))
|
||
{
|
||
var schemeInfo = await client.Queryable<WFSchemeInfo>().FirstAsync(a => a.Code == code);
|
||
if (schemeInfo != null)
|
||
{
|
||
var data = await client.Queryable<WFScheme>().FirstAsync(a => a.Id == schemeInfo.SchemeId);
|
||
if (data != null)
|
||
{
|
||
wfParams.Scheme = data.Content;
|
||
wfParams.SchemeCode = code;
|
||
wfParams.SchemeId = schemeInfo.SchemeId;
|
||
wfParams.SchemeName = schemeInfo.Name;
|
||
wfParams.ProcessId = processId;
|
||
wfParams.HasInstance = false;
|
||
|
||
wfParams.CreateUser = new WFUserInfo()
|
||
{
|
||
Id = userInfo.Id.ToString(),
|
||
Account = userInfo.Account,
|
||
Name = userInfo.Name
|
||
//CompanyId = userInfo.F_CompanyId,
|
||
//DepartmentId = userInfo.F_DepartmentId
|
||
};
|
||
}
|
||
else
|
||
{
|
||
throw new Exception(string.Format("无法获取对应的流程模板【{0}】", code));
|
||
}
|
||
}
|
||
else
|
||
{
|
||
throw new Exception(string.Format("无法获取对应的流程模板【{0}】", code));
|
||
}
|
||
}
|
||
else if (!string.IsNullOrEmpty(processId))
|
||
{
|
||
var processEntity = await GetEntity(processId);
|
||
if (processEntity != null)
|
||
{
|
||
var data = await client.Queryable<WFScheme>().FirstAsync(a => a.Id == processEntity.SchemeId);
|
||
if (data != null)
|
||
{
|
||
wfParams.Scheme = data.Content;
|
||
wfParams.SchemeCode = processEntity.SchemeCode;
|
||
wfParams.SchemeId = processEntity.SchemeId;
|
||
wfParams.SchemeName = processEntity.SchemeName;
|
||
wfParams.IsChild = processEntity.IsChild == 1;
|
||
wfParams.ParentProcessId = processEntity.ParentProcessId;
|
||
wfParams.ParentTaskId = processEntity.ParentTaskId;
|
||
wfParams.ParentNodeId = processEntity.ParentNodeId;
|
||
wfParams.ProcessId = processId;
|
||
wfParams.HasInstance = true;
|
||
wfParams.IsStart = processEntity.IsStart == 1 ? 1 : 0;
|
||
wfParams.Title = processEntity.Title;
|
||
|
||
wfParams.CreateUser = new WFUserInfo()
|
||
{
|
||
Id = processEntity.CreateUserId,
|
||
Account = processEntity.CreateUserAccount,
|
||
Name = processEntity.CreateUserName,
|
||
CompanyId = processEntity.CreateUserCompanyId,
|
||
DepartmentId = processEntity.CreateUserDepartmentId
|
||
};
|
||
}
|
||
else
|
||
{
|
||
throw new Exception(string.Format("无法获取流程模板【{0}】", processEntity.SchemeId));
|
||
}
|
||
}
|
||
else if (string.IsNullOrEmpty(wfParams.Scheme))
|
||
{
|
||
throw new Exception(string.Format("无法获取实例数据【{0}】", processId));
|
||
}
|
||
}
|
||
|
||
|
||
wfParams.NextUsers = nextUsers;
|
||
|
||
|
||
// 注册委托方法
|
||
wfEngineConfig.GetAwaitTaskList = GetAwaitTaskList;
|
||
wfEngineConfig.GetUserList = GetUserList;
|
||
wfEngineConfig.GetSystemUserList = GetSystemUserList;
|
||
wfEngineConfig.GetPrevTaskUserList = GetPrevTaskUserList;
|
||
wfEngineConfig.IsCountersignAgree = IsCountersignAgree;
|
||
wfEngineConfig.GetPrevUnitId = GetPrevUnitId;
|
||
|
||
|
||
IWFEngine iwfEngine = new WFEngine(wfEngineConfig, client);
|
||
|
||
return iwfEngine;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 获取等待任务
|
||
/// </summary>
|
||
/// <param name="processId">流程进程ID</param>
|
||
/// <param name="unitId">流程单元ID</param>
|
||
/// <returns></returns>
|
||
private async Task<List<WorkFlow.WFTask>> GetAwaitTaskList(string processId, string unitId)
|
||
{
|
||
List<WorkFlow.WFTask> res = new List<WorkFlow.WFTask>();
|
||
var list = await client.Queryable<WFTask>().Where(t => t.ProcessId == processId && t.UnitId == unitId && t.Type == 21 && t.State == 1).ToListAsync();
|
||
|
||
foreach (var item in list)
|
||
{
|
||
res.Add(GetWFTask(item));
|
||
}
|
||
return res;
|
||
}
|
||
/// <summary>
|
||
/// 获取设置人员
|
||
/// </summary>
|
||
/// <param name="auditorList">人员配置信息</param>
|
||
/// <param name="createUser">流程发起人</param>
|
||
/// <param name="processId">流程进程实例ID</param>
|
||
/// <param name="startNode">开始节点</param>
|
||
/// <returns></returns>
|
||
private async Task<List<WFUserInfo>> GetUserList(List<WFAuditor> auditorList, WFUserInfo createUser, string processId, WFUnit startNode)
|
||
{
|
||
var res = new List<WFUserInfo>();
|
||
List<string> userIds = new List<string>();
|
||
foreach (var item in auditorList)
|
||
{
|
||
switch (item.Type)
|
||
{
|
||
//岗位
|
||
case "1":
|
||
var rlist = await userManager.UserIdsByPosition("", item.Id);
|
||
foreach (var ritem in rlist)
|
||
{
|
||
userIds.Add(ritem);
|
||
}
|
||
break;
|
||
//角色
|
||
case "2":
|
||
var rlist2 = await userManager.UserIdsByRole(item.Id);
|
||
List<string> userIds2 = new List<string>();
|
||
foreach (var ritem2 in rlist2)
|
||
{
|
||
userIds2.Add(ritem2);
|
||
}
|
||
var userList2 = await GetListByKeyValues(userIds2.ToArray());
|
||
var userOrgs = await userManager.UserOrgsByUserIds(userIds2);
|
||
foreach (var userOrg in userOrgs)
|
||
{
|
||
var user2 = userList2.FirstOrDefault(a => a.Id.ToString() == userOrg.Key);
|
||
switch (item.Condition)
|
||
{
|
||
case "1":
|
||
if ((userOrg.Value as List<string>).Contains(createUser.DepartmentId))
|
||
{
|
||
res.Add(GetWFUserInfo(user2));
|
||
}
|
||
break;
|
||
//case "2":
|
||
// if (user2.CompanyId == createUser.CompanyId)
|
||
// {
|
||
// res.Add(GetWFUserInfo(user2));
|
||
// }
|
||
// break;
|
||
case "3":
|
||
//// 获取当前用户的岗位
|
||
var postList1 = await userManager.PositonsByUser(createUser.Id);// 发起人岗位
|
||
var postList2 = await userManager.PositonsByUser(user2.Id.ToString());// 节点审核人岗位
|
||
//if (await _postIBLL.IsUp(postList1, postList2))
|
||
if (await positionManager.IsUp(postList1, postList2))
|
||
{
|
||
res.Add(GetWFUserInfo(user2));
|
||
}
|
||
break;
|
||
case "4":
|
||
// 获取当前用户的岗位
|
||
var postList3 = await userManager.PositonsByUser(createUser.Id);// 发起人岗位
|
||
var postList4 = await userManager.PositonsByUser(user2.Id.ToString());// 节点审核人岗位
|
||
if (await positionManager.IsDown(postList3, postList4))
|
||
{
|
||
res.Add(GetWFUserInfo(user2));
|
||
}
|
||
break;
|
||
default:
|
||
res.Add(GetWFUserInfo(user2));
|
||
break;
|
||
}
|
||
}
|
||
break;
|
||
//用户
|
||
case "3":
|
||
userIds.Add(item.Id);
|
||
break;
|
||
//上下级
|
||
case "4":
|
||
var postIds = await userManager.PositonsByUser(createUser.Id);// 发起人岗位
|
||
int level = Convert.ToInt32(item.Id);
|
||
List<string> postList;
|
||
if (level < 6)
|
||
{
|
||
postList = (await positionManager.GetUpIdList(postIds, level)).ToList();
|
||
}
|
||
else
|
||
{
|
||
level = level - 5;
|
||
postList = (await positionManager.GetDownIdList(postIds, level)).ToList();
|
||
}
|
||
var userRelationList4 = await userManager.UserIdsByPositions(postList);
|
||
userIds.AddRange(userRelationList4);
|
||
break;
|
||
//节点执行人
|
||
case "5":
|
||
if (item.Id == startNode.Id)
|
||
{
|
||
res.Add(createUser);
|
||
}
|
||
else
|
||
{
|
||
var taskList = await GetLastFinishTaskList(item.Id, processId);
|
||
foreach (var task in taskList)
|
||
{
|
||
userIds.Add(task.UserId);
|
||
}
|
||
}
|
||
|
||
break;
|
||
//数据库表字段
|
||
case "6":
|
||
using (var db = this.CodeClient(item.DbCode, _configuration))
|
||
{
|
||
DataTable dt = await db.Ado.GetDataTableAsync(string.Format("select {0} from {1} where {2} = @processId ", item.AuditorField, item.Table, item.Rfield), new { processId });
|
||
foreach (DataRow row in dt.Rows)
|
||
{
|
||
var userIdString = row[0].ToString();
|
||
if (!string.IsNullOrEmpty(userIdString))
|
||
{
|
||
var userIdList = userIdString.Split(",");
|
||
foreach (var userIdItem in userIdList)
|
||
{
|
||
userIds.Add(userIdItem);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
//数据库表字段
|
||
case "7":
|
||
using (var db = this.CodeClient(item.DbCode, _configuration))
|
||
{
|
||
//获取数据id
|
||
var process = await client.Queryable<WFProcess>().FirstAsync(a => a.Id == processId);
|
||
WFInstanceInfo instanceInfo = null;
|
||
if (process != null)
|
||
{
|
||
// instanceInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<WFInstanceInfo>(process.InstanceInfo);
|
||
instanceInfo = process.InstanceInfo;
|
||
}
|
||
DataTable dt = await db.Ado.GetDataTableAsync(string.Format(item.Sql), new { pkeyValue = instanceInfo.pkeyValue });
|
||
foreach (DataRow row in dt.Rows)
|
||
{
|
||
var userIdString = row[0].ToString();
|
||
if (!string.IsNullOrEmpty(userIdString))
|
||
{
|
||
var userIdList = userIdString.Split(",");
|
||
foreach (var userIdItem in userIdList)
|
||
{
|
||
userIds.Add(userIdItem);
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
var userList = await GetListByKeyValues(userIds.ToArray());
|
||
foreach (var user in userList)
|
||
{
|
||
res.Add(GetWFUserInfo(user));
|
||
}
|
||
return res;
|
||
}
|
||
/// <summary>
|
||
/// 获取单元上一次的审核人
|
||
/// </summary>
|
||
/// <param name="processId">流程进程ID</param>
|
||
/// <param name="unitId">流程单元ID</param>
|
||
/// <returns></returns>
|
||
private async Task<List<WFUserInfo>> GetPrevTaskUserList(string processId, string unitId)
|
||
{
|
||
var res = new List<WFUserInfo>();
|
||
var list = await GetLastTaskList(processId, unitId);
|
||
foreach (var item in list)
|
||
{
|
||
if (!string.IsNullOrEmpty(item.UserId))
|
||
{
|
||
res.Add(new WFUserInfo()
|
||
{
|
||
Id = item.UserId,
|
||
Name = item.UserName,
|
||
CompanyId = item.UserCompanyId,
|
||
DepartmentId = item.UserDepartmentId,
|
||
IsAgree = item.IsAgree == 1,
|
||
//Sort = item,
|
||
State = (int)item.State
|
||
});
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
/// <summary>
|
||
/// 获取系统管理员
|
||
/// </summary>
|
||
/// <returns></returns>
|
||
private async Task<List<WFUserInfo>> GetSystemUserList()
|
||
{
|
||
var res = new List<WFUserInfo>();
|
||
|
||
var user = new SysUser
|
||
{
|
||
Id = -1,
|
||
Account = Define.SYSTEM_USERNAME,
|
||
Name = "超级管理员"
|
||
};
|
||
res.Add(GetWFUserInfo(user));
|
||
|
||
return res;
|
||
}
|
||
/// <summary>
|
||
/// 判断会签是否通过
|
||
/// </summary>
|
||
/// <param name="processId">流程进程ID</param>
|
||
/// <param name="unitId">流程单元ID</param>
|
||
/// <returns></returns>
|
||
private async Task<bool> IsCountersignAgree(string processId, string unitId)
|
||
{
|
||
var list = (List<WFTaskLog>)await GetLogList(processId, unitId);
|
||
if (list.Count == 0)
|
||
{
|
||
return false;
|
||
}
|
||
return list[0].IsAgree == 1;
|
||
}
|
||
/// <summary>
|
||
/// 获取上一个流入节点（不是驳回流入的）
|
||
/// </summary>
|
||
/// <param name="processId"></param>
|
||
/// <param name="unitId"></param>
|
||
/// <returns></returns>
|
||
private async Task<string> GetPrevUnitId(string processId, string unitId)
|
||
{
|
||
var data = await GetLastNotRejectTask(processId, unitId);
|
||
if (data != null)
|
||
{
|
||
return data.PrevUnitId;
|
||
}
|
||
else
|
||
{
|
||
return string.Empty;
|
||
}
|
||
}
|
||
/// <summary>
|
||
/// 获取流程任务数据
|
||
/// </summary>
|
||
/// <param name="wfTaskEntity"></param>
|
||
/// <returns></returns>
|
||
private WorkFlow.WFTask GetWFTask(WFTask wfTaskEntity)
|
||
{
|
||
var res = new WorkFlow.WFTask()
|
||
{
|
||
UnitId = wfTaskEntity.UnitId,
|
||
Name = wfTaskEntity.UnitName,
|
||
PrevUnitId = wfTaskEntity.PrevUnitId,
|
||
PrevUnitName = wfTaskEntity.PrevUnitName,
|
||
Token = wfTaskEntity.Token,
|
||
Type = (int)wfTaskEntity.Type
|
||
};
|
||
return res;
|
||
}
|
||
/// <summary>
|
||
/// 获取用户
|
||
/// </summary>
|
||
/// <param name="userEntity"></param>
|
||
/// <returns></returns>
|
||
private WFUserInfo GetWFUserInfo(SysUser userEntity)
|
||
{
|
||
var res = new WFUserInfo()
|
||
{
|
||
Id = userEntity.Id.ToString(),
|
||
Name = userEntity.Name,
|
||
Account = userEntity.Account,
|
||
//DepartmentId = userEntity.F_DepartmentId,
|
||
//CompanyId = userEntity.F_CompanyId,
|
||
IsNew = true
|
||
};
|
||
return res;
|
||
}
|
||
/// <summary>
|
||
/// 获取流程实例
|
||
/// </summary>
|
||
/// <param name="myParams">流程运行参数</param>
|
||
/// <param name="title">标题</param>
|
||
/// <returns></returns>
|
||
private WFProcess GetWFProcessEntity(WFParams myParams, string title)
|
||
{
|
||
WFProcess wfProcessEntity = new WFProcess()
|
||
{
|
||
Id = myParams.ProcessId,
|
||
SchemeCode = myParams.SchemeCode,
|
||
SchemeId = myParams.SchemeId,
|
||
SchemeName = myParams.SchemeName,
|
||
Title = title,
|
||
EnabledMark = 1,
|
||
IsAgain = 0,
|
||
IsFinished = 0,
|
||
IsChild = myParams.IsChild ? 1 : 0,
|
||
IsStart = 0,
|
||
IsCancel = 1,
|
||
ParentNodeId = myParams.ParentNodeId,
|
||
ParentProcessId = myParams.ParentProcessId,
|
||
ParentTaskId = myParams.ParentTaskId,
|
||
CreateUserId = myParams.CreateUser.Id,
|
||
CreateUserName = myParams.CreateUser.Name,
|
||
CreateUserAccount = myParams.CreateUser.Account,
|
||
CreateUserCompanyId = myParams.CreateUser.CompanyId,
|
||
CreateUserDepartmentId = myParams.CreateUser.DepartmentId,
|
||
UserId = _auth.GetUserId()
|
||
};
|
||
|
||
return wfProcessEntity;
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 处理任务
|
||
/// </summary>
|
||
/// <param name="list">任务列表</param>
|
||
/// <param name="iWFEngine"></param>
|
||
/// <param name="processId">流程进程实例</param>
|
||
/// <param name="prevToken">任务Token</param>
|
||
/// <param name="taskId">任务id</param>
|
||
/// <returns></returns>
|
||
private async Task<List<WFTask>> ExecuteWFTaskEntity(List<WorkFlow.WFTask> list, IWFEngine iWFEngine, string processId, string prevToken, string taskId = "")
|
||
{
|
||
var res = new List<WFTask>();
|
||
|
||
//单任务审核
|
||
var tlist = list.Where(r => r.Type == 7).ToList();
|
||
if (tlist.Count > 0)
|
||
{
|
||
var group = tlist.GroupBy(r => r.UnitId).ToList();
|
||
foreach (var item in group)
|
||
{
|
||
var taskuser = new List<WFTaskUser>();
|
||
var users = tlist.Where(r => r.UnitId == item.Key).ToList();
|
||
var userTask = new WFTask
|
||
{
|
||
Id = Guid.NewGuid().ToString(),
|
||
Type = users[0].Type,
|
||
ProcessId = processId,
|
||
Token = users[0].Token,
|
||
UnitId = users[0].UnitId,
|
||
UnitName = users[0].Name,
|
||
PrevUnitId = users[0].PrevUnitId,
|
||
PrevUnitName = users[0].PrevUnitName,
|
||
PrevToken = prevToken,
|
||
PrevTaskId = taskId,
|
||
UserId = users[0].User.Id,
|
||
UserName = users[0].User.Name,
|
||
UserDepartmentId = users[0].User.DepartmentId,
|
||
UserCompanyId = users[0].User.CompanyId,
|
||
State = users[0].User.IsAwait ? 2 : 1,
|
||
Sort = users[0].User.Sort,
|
||
IsReject = users[0].IsReject ? 1 : 0,
|
||
ChildProcessId = users[0].ChildSchemeInfoId,
|
||
|
||
TimeoutInterval = users[0].OvertimeMessageInterval,
|
||
TimeoutStrategy = users[0].OvertimeMessageType,
|
||
|
||
IsBatchAudit = users[0].IsBatchAudit ? 1 : 0,
|
||
ProcessUserId = iWFEngine.CreateUser.Id,
|
||
ProcessUserName = iWFEngine.CreateUser.Name,
|
||
ProcessCode = iWFEngine.Config.Params.SchemeCode,
|
||
ProcessTitle = iWFEngine.Config.Params.Title,
|
||
IsRetract=0
|
||
};
|
||
if (users[0].IsOvertimeMessage)
|
||
{
|
||
if (users[0].OvertimeGo > 0)
|
||
{
|
||
userTask.TimeoutAction = DateTime.Now.AddHours(users[0].OvertimeGo);
|
||
}
|
||
if (users[0].OvertimeMessageStart > 0)
|
||
{
|
||
userTask.TimeoutNotice = DateTime.Now.AddHours(users[0].OvertimeMessageStart);
|
||
}
|
||
}
|
||
foreach (var ts in users)
|
||
{
|
||
WFTaskUser tu = new WFTaskUser();
|
||
tu.UserId = ts.User.Id;
|
||
tu.TaskId = userTask.Id;
|
||
taskuser.Add(tu);
|
||
}
|
||
userTask.WFTaskUser = taskuser;
|
||
res.Add(userTask);
|
||
}
|
||
}
|
||
foreach (var item in list)
|
||
{
|
||
if (!string.IsNullOrEmpty(item.MessageType))
|
||
{
|
||
// 发送消息
|
||
var taskType = "";
|
||
switch (item.Type)
|
||
{
|
||
case 1:
|
||
case 5:
|
||
case 7:
|
||
taskType = "审核";
|
||
break;
|
||
case 2:
|
||
taskType = "查阅";
|
||
break;
|
||
case 3:
|
||
taskType = "提交";
|
||
break;
|
||
case 4:
|
||
taskType = "重新提交";
|
||
break;
|
||
}
|
||
if (!string.IsNullOrEmpty(taskType))
|
||
{
|
||
var msg = $"【{taskType}】{iWFEngine.Config.Params.Title},{item.Name}";
|
||
var userList = new List<string>();
|
||
userList.Add(item.User.Id);
|
||
//await _imMsgIBLL.SendMsg("IMWF", userList, msg, item.MessageType, item.Token);
|
||
}
|
||
}
|
||
|
||
string childSchemeInfoCode = "";
|
||
if (item.Type == 3)
|
||
{
|
||
var schemeInfo = await this.Repository.ChangeRepository<SugarRepositiry<WFSchemeInfo>>().GetByIdAsync(item.ChildSchemeInfoId);
|
||
if (schemeInfo != null)
|
||
{
|
||
childSchemeInfoCode = schemeInfo.Code;
|
||
}
|
||
}
|
||
|
||
switch (item.Type)
|
||
{
|
||
case 1:
|
||
case 2:
|
||
case 3:
|
||
case 4:
|
||
case 5:
|
||
var userTask = new WFTask
|
||
{
|
||
Type = item.Type,
|
||
ProcessId = processId,
|
||
Token = item.Token,
|
||
UnitId = item.UnitId,
|
||
UnitName = item.Name,
|
||
PrevUnitId = item.PrevUnitId,
|
||
PrevUnitName = item.PrevUnitName,
|
||
PrevToken = prevToken,
|
||
PrevTaskId = taskId,
|
||
UserId = item.User.Id,
|
||
UserName = item.User.Name,
|
||
UserDepartmentId = item.User.DepartmentId,
|
||
UserCompanyId = item.User.CompanyId,
|
||
State = item.User.IsAwait ? 2 : 1,
|
||
Sort = item.User.Sort,
|
||
IsReject = item.IsReject ? 1 : 0,
|
||
ChildProcessId = item.ChildSchemeInfoId,
|
||
ChildSchemeInfoCode = childSchemeInfoCode,
|
||
|
||
TimeoutInterval = item.OvertimeMessageInterval,
|
||
TimeoutStrategy = item.OvertimeMessageType,
|
||
|
||
IsBatchAudit = item.IsBatchAudit ? 1 : 0,
|
||
ProcessUserId = iWFEngine.CreateUser.Id,
|
||
ProcessUserName = iWFEngine.CreateUser.Name,
|
||
ProcessCode = iWFEngine.Config.Params.SchemeCode,
|
||
ProcessTitle = iWFEngine.Config.Params.Title,
|
||
IsRetract=0
|
||
};
|
||
if (item.IsOvertimeMessage)
|
||
{
|
||
if (item.OvertimeGo > 0)
|
||
{
|
||
userTask.TimeoutAction = DateTime.Now.AddHours(item.OvertimeGo);
|
||
}
|
||
if (item.OvertimeMessageStart > 0)
|
||
{
|
||
userTask.TimeoutNotice = DateTime.Now.AddHours(item.OvertimeMessageStart);
|
||
}
|
||
}
|
||
|
||
res.Add(userTask);
|
||
break;
|
||
case 10:
|
||
// 执行脚本
|
||
res.Add(new WFTask
|
||
{
|
||
Type = item.Type,
|
||
ProcessId = processId,
|
||
Token = item.Token,
|
||
UnitId = item.UnitId,
|
||
UnitName = item.Name,
|
||
PrevUnitId = item.PrevUnitId,
|
||
PrevUnitName = item.PrevUnitName,
|
||
PrevToken = prevToken
|
||
});
|
||
break;
|
||
case 21:
|
||
res.Add(new WFTask
|
||
{
|
||
Type = item.Type,
|
||
ProcessId = processId,
|
||
Token = item.Token,
|
||
UnitId = item.UnitId,
|
||
UnitName = item.Name,
|
||
PrevUnitId = item.PrevUnitId,
|
||
PrevUnitName = item.PrevUnitName,
|
||
PrevToken = prevToken,
|
||
State = 1,
|
||
});
|
||
break;
|
||
case 22:
|
||
await CloseTask(processId, item.UnitId, 21, taskId);
|
||
break;
|
||
case 23:
|
||
case 24:
|
||
WFTaskLog wfTaskLogEntity = new WFTaskLog()
|
||
{
|
||
Des = "系统任务",
|
||
TaskType = item.Type,
|
||
Token = item.Token,
|
||
ProcessId = processId,
|
||
UnitId = item.UnitId,
|
||
UnitName = item.Name,
|
||
PrevUnitId = item.PrevUnitId,
|
||
PrevUnitName = item.PrevUnitName
|
||
};
|
||
await AddLog(wfTaskLogEntity);
|
||
break;
|
||
case 26:
|
||
// 更新任务状态
|
||
await Update(processId, item.UnitId);
|
||
break;
|
||
}
|
||
}
|
||
return res;
|
||
}
|
||
|
||
public void AddOpenJob(WFTask task, DateTime outtime, DateTime overtime)
|
||
{
|
||
try
|
||
{
|
||
AddOrUpdateOpenJobReq req = new AddOrUpdateOpenJobReq();
|
||
req.JobName = $"超时通知 {task.Id}";
|
||
req.JobType = 0;
|
||
req.JobCallParams = "{\"TaskId\":\"" + task.Id + "\"}";
|
||
req.JobCall = "OpenAuth.App.BaseApp.Jobs.TaskTimeoutJob";
|
||
req.Status = 1;
|
||
req.Cron = GetCorn(outtime);
|
||
req.Remark = $"{task.ProcessUserId}--{task.UnitName}";
|
||
_job.AddStart(req);
|
||
|
||
AddOrUpdateOpenJobReq req1 = new AddOrUpdateOpenJobReq();
|
||
req1.JobName = $"严重超时通知 {task.Id}";
|
||
req1.JobType = 0;
|
||
req1.JobCallParams = "{\"TaskId\":\"" + task.Id + "\"}";
|
||
req1.JobCall = "OpenAuth.App.BaseApp.Jobs.TaskOverTimeJob";
|
||
req1.Status = 1;
|
||
req1.Cron = GetCorn(overtime);
|
||
req1.Remark = $"{task.ProcessUserId}--{task.UnitName}";
|
||
_job.AddStart(req1);
|
||
}
|
||
catch
|
||
{
|
||
return;
|
||
}
|
||
}
|
||
|
||
|
||
public string GetCorn(DateTime time)
|
||
{
|
||
StringBuilder sb = new StringBuilder();
|
||
sb.Append(time.Second.ToString());
|
||
sb.Append(" ");
|
||
sb.Append(time.Minute.ToString());
|
||
sb.Append(" ");
|
||
sb.Append(time.Hour.ToString());
|
||
sb.Append(" ");
|
||
sb.Append(time.Day.ToString());
|
||
sb.Append(" ");
|
||
sb.Append(time.Month.ToString());
|
||
sb.Append(" ");
|
||
sb.Append("?");
|
||
sb.Append(" ");
|
||
sb.Append(time.Year.ToString());
|
||
return sb.ToString();
|
||
}
|
||
/// <summary>
|
||
/// 执行脚本
|
||
/// </summary>
|
||
/// <param name="task">脚本任务</param>
|
||
/// <param name="code"></param>
|
||
/// <param name="processId"></param>
|
||
/// <param name="prevTaskId"></param>
|
||
/// <param name="createUser"></param>
|
||
/// <param name="iWFEngine"></param>
|
||
/// <param name="preTask"></param>
|
||
/// <returns></returns>
|
||
private async Task<bool> ExecuteScript(WFTask task, string code, string processId, string prevTaskId,string nextid, WFUserInfo createUser, IWFEngine iWFEngine, WFTask preTask,string des)
|
||
{
|
||
SysUser userInfo;
|
||
if (preTask == null)
|
||
{
|
||
userInfo = new SysUser()
|
||
{
|
||
Id = long.Parse(createUser.Id),
|
||
Account = createUser.Account,
|
||
//CompanyId = createUser.CompanyId,
|
||
//F_DepartmentId = createUser.DepartmentId
|
||
};
|
||
}
|
||
else
|
||
{
|
||
//userInfo = await this.CurrentUser(preTask.F_UserId);
|
||
userInfo = _auth.GetCurrentUser().User;
|
||
}
|
||
string nextnode = "";
|
||
if (!string.IsNullOrEmpty(nextid))
|
||
{
|
||
nextnode = iWFEngine.GetNode(nextid).Name;
|
||
}
|
||
|
||
var process = await client.Queryable<WFProcess>().FirstAsync(a => a.Id == processId);
|
||
|
||
WFInstanceInfo instanceInfo = null;
|
||
if (process != null)
|
||
{
|
||
// instanceInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<WFInstanceInfo>(process.InstanceInfo);
|
||
instanceInfo = process.InstanceInfo;
|
||
}
|
||
|
||
var param = new
|
||
{
|
||
processId,
|
||
parentprocessId=process.ParentProcessId,
|
||
userId = createUser.Id,
|
||
userAccount = createUser.Account,
|
||
companyId = createUser.CompanyId,
|
||
departmentId = createUser.DepartmentId,
|
||
userName2 = userInfo.Name,
|
||
userId2 = userInfo.Id.ToString(),
|
||
userAccount2 = userInfo.Account,
|
||
//companyId2 = userInfo.F_CompanyId,
|
||
//departmentId2 = userInfo.F_DepartmentId,
|
||
code,
|
||
nodeName=nextnode,
|
||
pkeyValue = instanceInfo == null ? "" : instanceInfo.pkeyValue,
|
||
des=des
|
||
};
|
||
try
|
||
{
|
||
var node = iWFEngine.GetNode(task.UnitId);
|
||
switch (node.ExecuteType)
|
||
{
|
||
case "1":
|
||
if (!string.IsNullOrEmpty(node.SqlDb) && !string.IsNullOrEmpty(node.SqlStr))
|
||
{
|
||
await client.Ado.ExecuteCommandAsync(node.SqlStr, param);
|
||
}
|
||
break;
|
||
case "2":
|
||
if (!string.IsNullOrEmpty(node.Ioc) && IocManager.Instance.IsRegistered<WorkFlow.IWorkFlowMethod>(node.Ioc))
|
||
{
|
||
WorkFlow.IWorkFlowMethod iWorkFlowMethod = IocManager.Instance.GetService<WorkFlow.IWorkFlowMethod>(node.Ioc);
|
||
WorkFlow.WfMethodParameter wfMethodParameter = new WorkFlow.WfMethodParameter()
|
||
{
|
||
ProcessId = processId,
|
||
UnitName = task.UnitName,
|
||
TaskId = prevTaskId,
|
||
Code = code,
|
||
UserId = createUser.Id,
|
||
UserAccount = createUser.Account,
|
||
CompanyId = createUser.CompanyId,
|
||
DepartmentId = createUser.DepartmentId
|
||
};
|
||
await iWorkFlowMethod.Execute(wfMethodParameter);
|
||
}
|
||
break;
|
||
case "3":
|
||
if (!string.IsNullOrEmpty(node.ApiUrl))
|
||
{
|
||
await HttpMethods.Post(node.ApiUrl, Json.ToJson(param));
|
||
}
|
||
break;
|
||
|
||
}
|
||
|
||
/*脚本执行成功*/
|
||
WFTaskLog wfTaskLogEntity = new WFTaskLog()
|
||
{
|
||
Des = "脚本执行成功",
|
||
TaskType = 99,
|
||
ProcessId = processId,
|
||
TaskId = task.Id,
|
||
UnitId = task.UnitId,
|
||
UnitName = task.UnitName
|
||
};
|
||
await AddLog(wfTaskLogEntity);
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
WFTaskLog wfTaskLogEntity = new WFTaskLog()
|
||
{
|
||
Des = string.Format("脚本执行异常:{0}", ex.Message),
|
||
TaskType = 99,
|
||
ProcessId = processId,
|
||
TaskId = task.Id,
|
||
UnitId = task.UnitId,
|
||
UnitName = task.UnitName
|
||
};
|
||
await AddLog(wfTaskLogEntity);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 执行脚本
|
||
/// </summary>
|
||
/// <param name="processId"></param>
|
||
/// <param name="code"></param>
|
||
/// <param name="createUser"></param>
|
||
/// <param name="executeType"></param>
|
||
/// <param name="sqlDb"></param>
|
||
/// <param name="sqlStr"></param>
|
||
/// <param name="apiUrl"></param>
|
||
/// <param name="iocName"></param>
|
||
/// <returns></returns>
|
||
private async Task<bool> ExecuteScript(string processId, string code, WFUserInfo createUser, string executeType, string sqlDb, string sqlStr, string apiUrl, string iocName)
|
||
{
|
||
var param = new
|
||
{
|
||
processId,
|
||
userId = createUser.Id,
|
||
userAccount = createUser.Account,
|
||
companyId = createUser.CompanyId,
|
||
departmentId = createUser.DepartmentId,
|
||
code
|
||
};
|
||
|
||
try
|
||
{
|
||
switch (executeType)
|
||
{
|
||
case "1":
|
||
if (!string.IsNullOrEmpty(sqlDb) && !string.IsNullOrEmpty(sqlStr))
|
||
{
|
||
//await wfProcessSerive.BaseRepository(sqlDb).ExecuteSql(sqlStr, param);
|
||
await client.Ado.ExecuteCommandAsync(sqlStr, param);
|
||
}
|
||
break;
|
||
case "2":
|
||
if (!string.IsNullOrEmpty(iocName) && IocManager.Instance.IsRegistered<WorkFlow.IWorkFlowMethod>(iocName))
|
||
{
|
||
WorkFlow.IWorkFlowMethod iWorkFlowMethod = IocManager.Instance.GetService<WorkFlow.IWorkFlowMethod>(iocName);
|
||
WorkFlow.WfMethodParameter wfMethodParameter = new WorkFlow.WfMethodParameter()
|
||
{
|
||
ProcessId = processId,
|
||
Code = code,
|
||
UserId = createUser.Id,
|
||
UserAccount = createUser.Account,
|
||
CompanyId = createUser.CompanyId,
|
||
DepartmentId = createUser.DepartmentId
|
||
};
|
||
await iWorkFlowMethod.Execute(wfMethodParameter);
|
||
}
|
||
break;
|
||
case "3":
|
||
if (!string.IsNullOrEmpty(apiUrl))
|
||
{
|
||
await HttpMethods.Post(apiUrl, Json.ToJson(param));
|
||
}
|
||
break;
|
||
}
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 执行脚本(撤销)
|
||
/// </summary>
|
||
/// <param name="unitId"></param>
|
||
/// <param name="unitName"></param>
|
||
/// <param name="processId"></param>
|
||
/// <param name="createUser"></param>
|
||
/// <param name="iWFEngine"></param>
|
||
/// <returns></returns>
|
||
private async Task ExecuteRevokeScript(string unitId, string unitName, string processId, WFUserInfo createUser, IWFEngine iWFEngine)
|
||
{
|
||
var param = new
|
||
{
|
||
processId,
|
||
userId = createUser.Id,
|
||
userAccount = createUser.Account,
|
||
companyId = createUser.CompanyId,
|
||
departmentId = createUser.DepartmentId,
|
||
code = "revoke",
|
||
};
|
||
try
|
||
{
|
||
var node = iWFEngine.GetNode(unitId);
|
||
switch (node.ExecuteType)
|
||
{
|
||
case "1":
|
||
if (!string.IsNullOrEmpty(node.SqlDb) && !string.IsNullOrEmpty(node.SqlStrRevoke))
|
||
{
|
||
//await wfProcessSerive.BaseRepository(node.SqlDb).ExecuteSql(node.SqlStrRevoke, param);
|
||
await client.Ado.ExecuteCommandAsync(node.SqlStrRevoke, param);
|
||
}
|
||
break;
|
||
case "2":
|
||
if (!string.IsNullOrEmpty(node.IocRevoke) && IocManager.Instance.IsRegistered<WorkFlow.IWorkFlowMethod>(node.IocRevoke))
|
||
{
|
||
WorkFlow.IWorkFlowMethod iWorkFlowMethod = IocManager.Instance.GetService<WorkFlow.IWorkFlowMethod>(node.IocRevoke);
|
||
WorkFlow.WfMethodParameter wfMethodParameter = new WorkFlow.WfMethodParameter()
|
||
{
|
||
ProcessId = processId,
|
||
UnitName = unitName,
|
||
Code = "revoke",
|
||
UserId = createUser.Id,
|
||
UserAccount = createUser.Account,
|
||
CompanyId = createUser.CompanyId,
|
||
DepartmentId = createUser.DepartmentId
|
||
};
|
||
await iWorkFlowMethod.Execute(wfMethodParameter);
|
||
}
|
||
break;
|
||
case "3":
|
||
if (!string.IsNullOrEmpty(node.ApiUrlRevoke))
|
||
{
|
||
await HttpMethods.Post(node.ApiUrlRevoke, Json.ToJson(param));
|
||
}
|
||
break;
|
||
|
||
}
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
WFTaskLog wfTaskLogEntity = new WFTaskLog()
|
||
{
|
||
Des = string.Format("脚本执行异常:{0}", ex.Message),
|
||
TaskType = 99,
|
||
ProcessId = processId,
|
||
UnitId = unitId,
|
||
UnitName = $"{unitName}-撤销"
|
||
};
|
||
await AddLog(wfTaskLogEntity);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// 普通审核
|
||
/// </summary>
|
||
/// <param name="iWFEngine"></param>
|
||
/// <param name="taskEntity"></param>
|
||
/// <param name="code"></param>
|
||
/// <param name="name"></param>
|
||
/// <param name="nextId">下一个节点</param>
|
||
/// <param name="des"></param>
|
||
/// <param name="stampImg"></param>
|
||
/// <returns></returns>
|
||
private async Task AuditNode(IWFEngine iWFEngine, WFTask taskEntity, string code, string name, string des, string stampImg, string nextId = "")
|
||
{
|
||
// 下一部需要执行的任务
|
||
var taskList = await iWFEngine.GetTask(taskEntity.UnitId, code, nextId);
|
||
if (taskList.FindAll(t => t.Type != 10).Count == 0)
|
||
{
|
||
throw (new Exception("找不到下一个流转节点！"));
|
||
}
|
||
|
||
List<WFTask> myTaskList;
|
||
// 处理任务并更新数据
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
var process = await uwo.WFProcess.GetByIdAsync(taskEntity.ProcessId);
|
||
await uwo.Db.Updateable<WFProcess>()
|
||
.SetColumns(p => new WFProcess { IsStart = 1, IsCancel = 0 })
|
||
.SetColumnsIF(taskList.FindIndex(t => t.Type == 100) != -1, p => p.IsFinished == 1)
|
||
.SetColumnsIF(taskList.FindIndex(t => t.Type == 4) != -1, p => p.IsAgain == 1)
|
||
.Where(p => p.Id == taskEntity.ProcessId)
|
||
.ExecuteCommandAsync();
|
||
if (taskList.FindIndex(t => t.Type == 100) != -1)
|
||
{
|
||
if (process.IsChild == 1)
|
||
{
|
||
await ChildrenEndTask(process.ParentProcessId, process.ParentNodeId, code, taskEntity, nextId);
|
||
}
|
||
}
|
||
|
||
// 更新任务状态
|
||
taskEntity.IsAgree = code == "disagree" ? 0 : 1;
|
||
taskEntity.State = 3;
|
||
if (taskEntity.Type == 7)
|
||
{
|
||
var currentUser = _auth.GetCurrentUser().User;
|
||
taskEntity.UserId = currentUser.Id.ToString();
|
||
taskEntity.UserName = currentUser.Name;
|
||
}
|
||
await uwo.WFTask.UpdateAsync(taskEntity);
|
||
|
||
// 更新上一个流转过来的任务，提示他无法被撤销
|
||
await CloseTaskLogCancel(taskEntity.ProcessId, taskEntity.PrevTaskId);
|
||
|
||
// 关闭同一个节点，其他人的任务
|
||
await CloseTask(taskEntity.ProcessId, taskEntity.Token, taskEntity.Id);
|
||
|
||
myTaskList = await ExecuteWFTaskEntity(taskList, iWFEngine, taskEntity.ProcessId, taskEntity.Token, taskEntity.Id);
|
||
foreach (var item in myTaskList)
|
||
{
|
||
if (item.Type == 7)
|
||
{
|
||
await uwo.WFTaskUser.InsertRangeAsync(item.WFTaskUser);
|
||
}
|
||
await Add(item);
|
||
}
|
||
|
||
await CreateTaskLog(taskEntity, code, name, des, stampImg);
|
||
|
||
uwo.Commit();
|
||
}
|
||
|
||
|
||
// 脚本执行
|
||
var scriptTaskList = myTaskList.FindAll(t => t.Type == 10);
|
||
foreach (var item in scriptTaskList)
|
||
{
|
||
await ExecuteScript(item, code, taskEntity.ProcessId, taskEntity.Id, nextId, iWFEngine.CreateUser, iWFEngine, taskEntity,des);
|
||
}
|
||
}
|
||
|
||
|
||
/// <summary>
|
||
/// 子流程结束，获取父流程下一任务
|
||
/// </summary>
|
||
/// <param name="processId">父流程id</param>
|
||
/// <param name="unitId">父流程的节点id</param>
|
||
/// <param name="code">上一任务code（类似agress，degress）</param>
|
||
/// <param name="taskEntity">任务</param>
|
||
/// <param name="nextId">下一节点</param>
|
||
/// <returns></returns>
|
||
private async Task ChildrenEndTask(string processId, string unitId, string code, WFTask taskEntity, string nextId = "")
|
||
{
|
||
var process = await GetEntity(processId);
|
||
var iWFEngine = await Bootstraper("", processId, null, null);
|
||
// 下一部需要执行的任务
|
||
var taskList = await iWFEngine.GetTask(unitId, code, nextId);
|
||
if (taskList.FindAll(t => t.Type != 10).Count == 0)
|
||
{
|
||
throw (new Exception("找不到下一个流转节点！"));
|
||
}
|
||
|
||
// 处理任务并更新数据
|
||
//wfProcessSerive.BeginTrans();
|
||
List<WFTask> myTaskList;
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
try
|
||
{
|
||
// 更新流程状态
|
||
await uwo.Db.Updateable<WFProcess>()
|
||
.SetColumns(p => new WFProcess { IsStart = 1, IsCancel = 0 })
|
||
.SetColumnsIF(taskList.FindIndex(t => t.Type == 100) != -1, p => p.IsFinished == 1)
|
||
.SetColumnsIF(taskList.FindIndex(t => t.Type == 4) != -1, p => p.IsAgain == 1)
|
||
.Where(p => p.Id == processId)
|
||
.ExecuteCommandAsync();
|
||
|
||
if (taskList.FindIndex(t => t.Type == 100) != -1)
|
||
{
|
||
if (process.IsChild == 1)
|
||
{
|
||
await ChildrenEndTask(process.ParentProcessId, process.ParentNodeId, code, taskEntity, nextId);
|
||
}
|
||
}
|
||
|
||
myTaskList = await ExecuteWFTaskEntity(taskList, iWFEngine, processId, taskEntity.Token, taskEntity.Id);
|
||
foreach (var item in myTaskList)
|
||
{
|
||
if (item.Type == 7)
|
||
{
|
||
await uwo.WFTaskUser.InsertRangeAsync(item.WFTaskUser);
|
||
}
|
||
await Add(item);
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
throw;
|
||
}
|
||
uwo.Commit();
|
||
}
|
||
// 脚本执行
|
||
var scriptTaskList = myTaskList.FindAll(t => t.Type == 10);
|
||
foreach (var item in scriptTaskList)
|
||
{
|
||
await ExecuteScript(item, code, processId, taskEntity.Id, nextId, iWFEngine.CreateUser, iWFEngine, taskEntity,"");
|
||
}
|
||
}
|
||
|
||
|
||
private async Task AuditNodeByCountersign(IWFEngine iWFEngine, WFTask taskEntiy, string code, string name, string des, string stampImg)
|
||
{
|
||
taskEntiy.IsAgree = code == "disagree" ? 0 : 1;
|
||
var node = iWFEngine.GetNode(taskEntiy.UnitId);
|
||
var list = (List<WFTask>)await GetLastTaskList(taskEntiy.ProcessId, taskEntiy.UnitId);
|
||
var myIndex = list.FindIndex(t => t.Id == taskEntiy.Id);
|
||
if (myIndex == -1)
|
||
{
|
||
throw (new Exception("会签任务记录异常无法审核！"));
|
||
}
|
||
|
||
if (taskEntiy.IsAgree == 0)
|
||
{
|
||
if (node.CountersignType == "1")
|
||
{
|
||
// 并行
|
||
if (node.IsCountersignAll)
|
||
{
|
||
// 等待
|
||
if (list.FindIndex(t => t.Id != taskEntiy.Id && t.State == 1) != -1)
|
||
{
|
||
// 表示还有人没有审核
|
||
// 表示还有任务没有完成
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
WFProcess processEntity = new WFProcess()
|
||
{
|
||
Id = taskEntiy.ProcessId,
|
||
IsStart = 1,
|
||
IsCancel = 0,
|
||
};
|
||
await uwo.WFProcess.UpdateAsync(processEntity);
|
||
taskEntiy.State = 3;
|
||
await uwo.WFTask.UpdateAsync(taskEntiy);
|
||
await CreateTaskLog(taskEntiy, code, name, des, stampImg);
|
||
|
||
uwo.Commit();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var num = await GetTaskUserMaxNum(taskEntiy.ProcessId, taskEntiy.UnitId);
|
||
var fnum = list.FindAll(t => t.State == 3 && t.IsAgree == 0).Count + 1;
|
||
if ((num - fnum) * 100 / num >= node.CountersignAllType)
|
||
{
|
||
await AuditNode(iWFEngine, taskEntiy, "agree", "同意", des, stampImg);
|
||
}
|
||
else
|
||
{
|
||
await AuditNode(iWFEngine, taskEntiy, code, name, des, stampImg);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 不等待，每次都需要计算通过率
|
||
var num = await GetTaskUserMaxNum(taskEntiy.ProcessId, taskEntiy.UnitId);
|
||
var fnum = list.FindAll(t => t.State == 3 && t.IsAgree == 0).Count + 1;
|
||
if ((num - fnum) * 100 / num >= node.CountersignAllType)// 表示还有通过的希望
|
||
{
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
WFProcess processEntity = new WFProcess()
|
||
{
|
||
Id = taskEntiy.ProcessId,
|
||
IsStart = 1,
|
||
IsCancel = 0,
|
||
};
|
||
await uwo.WFProcess.UpdateAsync(processEntity);
|
||
taskEntiy.State = 3;
|
||
await uwo.WFTask.UpdateAsync(taskEntiy);
|
||
await CreateTaskLog(taskEntiy, code, name, des, stampImg);
|
||
|
||
uwo.Commit();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
await AuditNode(iWFEngine, taskEntiy, code, name, des, stampImg);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 串行
|
||
await AuditNode(iWFEngine, taskEntiy, code, name, des, stampImg);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (node.CountersignType == "1")
|
||
{
|
||
// 并行
|
||
|
||
// 如果不等待，不同意直接跳转
|
||
if (node.IsCountersignAll)
|
||
{
|
||
if (list.FindIndex(t => t.Id != taskEntiy.Id && t.State == 1) != -1) // 表示还有人没有处理完
|
||
{
|
||
// 表示还有任务没有完成
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
WFProcess processEntity = new WFProcess()
|
||
{
|
||
Id = taskEntiy.ProcessId,
|
||
IsStart = 1,
|
||
IsCancel = 0,
|
||
};
|
||
await uwo.WFProcess.UpdateAsync(processEntity);
|
||
taskEntiy.State = 3;
|
||
await uwo.WFTask.UpdateAsync(taskEntiy);
|
||
await CreateTaskLog(taskEntiy, code, name, des, stampImg);
|
||
uwo.Commit();
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var num = await GetTaskUserMaxNum(taskEntiy.ProcessId, taskEntiy.UnitId);
|
||
var fnum = list.FindAll(t => t.State == 3 && t.IsAgree == 0).Count;
|
||
if ((num - fnum) * 100 / num >= node.CountersignAllType)
|
||
{
|
||
await AuditNode(iWFEngine, taskEntiy, "agree", "同意", des, stampImg);
|
||
}
|
||
else
|
||
{
|
||
await AuditNode(iWFEngine, taskEntiy, "disagree", "不同意", des, stampImg);
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
var num = await GetTaskUserMaxNum(taskEntiy.ProcessId, taskEntiy.UnitId);
|
||
var snum = list.FindAll(t => t.State == 3 && t.IsAgree == 1).Count;
|
||
if (snum * 100 / num >= node.CountersignAllType)
|
||
{
|
||
await AuditNode(iWFEngine, taskEntiy, "agree", "同意", des, stampImg);
|
||
}
|
||
else
|
||
{
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
WFProcess processEntity = new WFProcess()
|
||
{
|
||
Id = taskEntiy.ProcessId,
|
||
IsStart = 1,
|
||
IsCancel = 0,
|
||
};
|
||
await uwo.WFProcess.UpdateAsync(processEntity);
|
||
taskEntiy.State = 3;
|
||
await uwo.WFTask.UpdateAsync(taskEntiy);
|
||
await CreateTaskLog(taskEntiy, code, name, des, stampImg);
|
||
|
||
uwo.Commit();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 串行
|
||
if (myIndex == list.Count - 1) // 表示最后一个人审核完成，然后往下执行
|
||
{
|
||
await AuditNode(iWFEngine, taskEntiy, code, name, des, stampImg);
|
||
}
|
||
else
|
||
{
|
||
// 表示还有任务没有完成
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
WFProcess processEntity = new WFProcess()
|
||
{
|
||
Id = taskEntiy.ProcessId,
|
||
IsStart = 1,
|
||
IsCancel = 0,
|
||
};
|
||
await uwo.WFProcess.UpdateAsync(processEntity);
|
||
taskEntiy.State = 3;
|
||
await uwo.WFTask.UpdateAsync(taskEntiy);
|
||
await CreateTaskLog(taskEntiy, code, name, des, stampImg);
|
||
|
||
|
||
if (node.CountersignType == "2")
|
||
{
|
||
// 串行，更新上一个任务的撤销操作，开启下一个任务
|
||
if (myIndex == 0)
|
||
{
|
||
await CloseTaskLogCancel(taskEntiy.ProcessId, taskEntiy.PrevTaskId);
|
||
}
|
||
else
|
||
{
|
||
await CloseTaskLogCancel(list[myIndex - 1].Id);
|
||
}
|
||
await uwo.WFTask.UpdateAsync(new WFTask { Id = list[myIndex + 1].Id, State = 1 });
|
||
}
|
||
var flag = uwo.Commit();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 创建日志
|
||
/// </summary>
|
||
/// <param name="taskEntiy"></param>
|
||
/// <param name="code"></param>
|
||
/// <param name="name"></param>
|
||
/// <param name="des"></param>
|
||
/// <param name="stampImg"></param>
|
||
/// <returns></returns>
|
||
private async Task CreateTaskLog(WFTask taskEntiy, string code, string name, string des, string stampImg)
|
||
{
|
||
|
||
WFTaskLog wfTaskLogEntity = new WFTaskLog()
|
||
{
|
||
Des = $"【{name}】{des}",
|
||
TaskType = taskEntiy.Type,
|
||
ProcessId = taskEntiy.ProcessId,
|
||
UnitId = taskEntiy.UnitId,
|
||
UnitName = taskEntiy.UnitName,
|
||
IsAgree = taskEntiy.IsAgree,
|
||
OperationCode = code,
|
||
OperationName = name,
|
||
Token = taskEntiy.Token,
|
||
PrevUnitId = taskEntiy.PrevUnitId,
|
||
PrevUnitName = taskEntiy.PrevUnitName,
|
||
TaskId = taskEntiy.Id,
|
||
StampImg = stampImg,
|
||
IsCancel = 1,
|
||
IsLast = 1
|
||
|
||
};
|
||
|
||
await UpdateLog(taskEntiy.ProcessId, taskEntiy.UnitId);
|
||
await AddLog(wfTaskLogEntity);
|
||
}
|
||
#endregion
|
||
|
||
|
||
public async Task<Response<bool>> Supervise(string processId,int supervise = 1)
|
||
{
|
||
// todo 实现督办
|
||
|
||
var iWFEngine = await Bootstraper(string.Empty, processId, null, null);
|
||
// 获取未完成的任务
|
||
var taskList = await GetUnFinishTaskList(processId);
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
|
||
foreach (var item in taskList)
|
||
{
|
||
if (item.Type == 1 || item.Type == 3 || item.Type == 5 || item.Type == 6 || item.Type == 7)
|
||
{
|
||
|
||
// 督办时间督办标志
|
||
item.IsSupervise = supervise;
|
||
item.SuperviseTime = DateTime.Now;
|
||
item.SuperviseId = _auth.GetCurrentUser().User.Id;
|
||
// 发送消息
|
||
var msg = $"【审核】【督办】{item.ProcessTitle},{item.UnitName}";
|
||
var userList = new List<string>();
|
||
// todo 单体任务处理
|
||
userList.Add(item.UserId);
|
||
var node = iWFEngine.GetNode(item.UnitId);
|
||
//await _imMsgIBLL.SendMsg("IMWF", userList, msg, node.MessageType, item.F_Token);
|
||
|
||
await uwo.WFTask.UpdateAsync(item);
|
||
}
|
||
}
|
||
|
||
//await wfProcessSerive.Update(new WFProcessEntity() { F_IsUrge = 1, F_Id = processId });
|
||
|
||
var wfTaskLogEntity = new WFTaskLog
|
||
{
|
||
Des = "督办审核",
|
||
TaskType = 98,
|
||
ProcessId = processId,
|
||
UnitId = iWFEngine.StartNode.Id,
|
||
UnitName = string.IsNullOrEmpty(iWFEngine.StartNode.Name) ? "开始节点" : iWFEngine.StartNode.Name,
|
||
CreateDate = DateTime.Now,
|
||
UserId = _auth.GetUserId(),
|
||
UserName = _auth.GetUserNickName(),
|
||
Id = Guid.NewGuid().ToString()
|
||
};
|
||
|
||
await uwo.WFTaskLog.InsertAsync(wfTaskLogEntity);
|
||
|
||
var flag = uwo.Commit();
|
||
return new Response<bool>
|
||
{
|
||
Result = flag,
|
||
Message = flag ? "success" : "error"
|
||
};
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
#region 撤回
|
||
/// <summary>
|
||
/// 撤回流程
|
||
/// </summary>
|
||
/// <param name="taskId">流程任务主键</param>
|
||
/// <param name="code">流程审批操作码agree 同意 disagree 不同意 lrtimeout 超时</param>
|
||
/// <param name="name">流程审批操名称</param>
|
||
/// <param name="des">审批意见</param>
|
||
/// <param name="nextUsers">下一节点指定审核人</param>
|
||
/// <param name="stampImg">盖章图片</param>
|
||
/// <param name="stampPassWord">盖章图片密码</param>
|
||
/// <param name="nextId">下一个审核节点</param>
|
||
public async Task RetractFlow(string taskId, string code, string name, string des, Dictionary<string, string> nextUsers, string stampImg, string stampPassWord, string nextId)
|
||
{
|
||
var taskEntiy = await client.Queryable<WFTask>().Where(a => a.Id == taskId).FirstAsync();
|
||
if (taskEntiy == null)
|
||
{
|
||
throw (new Exception("找不到对应流程任务！"));
|
||
}
|
||
else if (taskEntiy.State != 3&& taskEntiy.State != 4)
|
||
{
|
||
throw (new Exception("该任务未完成！"));
|
||
}
|
||
|
||
//后期改
|
||
stampImg = "";
|
||
//stampImg = await _wFStampIBLL.ToWfImg(stampImg, stampPassWord);
|
||
|
||
var iWFEngine = await Bootstraper("", taskEntiy.ProcessId, null, nextUsers);
|
||
|
||
// 1.判断任务类型 1 普通任务 5 会签任务
|
||
if (taskEntiy.Type == 1 || taskEntiy.Type == 7)
|
||
{
|
||
await RetractNode(iWFEngine, taskEntiy, code, name, des, stampImg, nextId);
|
||
}
|
||
else
|
||
{
|
||
throw (new Exception("该任务无法审核！"));
|
||
}
|
||
|
||
//await _imMsgIBLL.VirtualDeleteByContentId(taskEntiy.F_Token); // 更新消息
|
||
|
||
// 发送消息
|
||
var msg = $"【提醒】{iWFEngine.Config.Params.Title},{taskEntiy.UnitName}已被撤回";
|
||
var userList = new List<string>();
|
||
userList.Add(iWFEngine.CreateUser.Id);
|
||
var node = iWFEngine.StartNode;
|
||
//await _imMsgIBLL.SendMsg("IMWF", userList, msg, node.MessageType, iWFEngine.Config.Params.ProcessId);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 撤回
|
||
/// </summary>
|
||
/// <param name="iWFEngine"></param>
|
||
/// <param name="taskEntity"></param>
|
||
/// <param name="code"></param>
|
||
/// <param name="name"></param>
|
||
/// <param name="nextId">下一个节点</param>
|
||
/// <param name="des"></param>
|
||
/// <param name="stampImg"></param>
|
||
/// <returns></returns>
|
||
private async Task RetractNode(IWFEngine iWFEngine, WFTask taskEntity, string code, string name, string des, string stampImg, string nextId = "")
|
||
{
|
||
// 下一部需要执行的任务
|
||
var taskList = await iWFEngine.GetTask(taskEntity.UnitId, code, nextId);
|
||
|
||
List<WFTask> myTaskList;
|
||
//修改原有任务的IsLast状态
|
||
await client.Updateable<WFTask>()
|
||
.SetColumns(t => new WFTask() { IsLast = 0 })
|
||
.Where(t => t.Id==taskEntity.Id)
|
||
.ExecuteCommandAsync();
|
||
|
||
//删除该节点之后生成的所有任务
|
||
var dellist=client.Queryable<WFTask>().Where(r=>r.CreateDate>taskEntity.CreateDate&&r.ProcessId==taskEntity.ProcessId).ToList();
|
||
await client.Deleteable<WFTask>(dellist).ExecuteCommandAsync();
|
||
// 处理任务并更新数据
|
||
using (var uwo = UnitWork.CreateContext())
|
||
{
|
||
var process = await uwo.WFProcess.GetByIdAsync(taskEntity.ProcessId);
|
||
await uwo.Db.Updateable<WFProcess>()
|
||
.SetColumns(p => new WFProcess { IsStart = 1, IsCancel = 0 })
|
||
.SetColumns(p=>p.IsFinished==0)
|
||
.SetColumnsIF(taskList.FindIndex(t => t.Type == 100) != -1, p => p.IsFinished == 1)
|
||
.SetColumnsIF(taskList.FindIndex(t => t.Type == 4) != -1, p => p.IsAgain == 1)
|
||
.Where(p => p.Id == taskEntity.ProcessId)
|
||
.ExecuteCommandAsync();
|
||
if (taskList.FindIndex(t => t.Type == 100) != -1)
|
||
{
|
||
if (process.IsChild == 1)
|
||
{
|
||
await ChildrenEndTask(process.ParentProcessId, process.ParentNodeId, code, taskEntity, nextId);
|
||
}
|
||
}
|
||
|
||
var newTask = new WFTask
|
||
{
|
||
Id = Guid.NewGuid().ToString(),
|
||
Type = taskEntity.Type,
|
||
ProcessId = taskEntity.ProcessId,
|
||
Token = Guid.NewGuid().ToString(),
|
||
UnitId = taskEntity.UnitId,
|
||
UnitName = taskEntity.UnitName,
|
||
PrevUnitId = taskEntity.PrevUnitId,
|
||
PrevUnitName = taskEntity.PrevUnitName,
|
||
PrevToken = taskEntity.Token,
|
||
PrevTaskId = taskEntity.Id,
|
||
UserId = taskEntity.UserId,
|
||
UserName = taskEntity.UserName,
|
||
UserDepartmentId = taskEntity.UserDepartmentId,
|
||
UserCompanyId = taskEntity.UserCompanyId,
|
||
State = 1,
|
||
Sort = taskEntity.Sort,
|
||
IsReject = 0,
|
||
ChildProcessId = taskEntity.ChildProcessId,
|
||
ChildSchemeInfoCode = taskEntity.ChildSchemeInfoCode,
|
||
|
||
TimeoutInterval = taskEntity.TimeoutInterval,
|
||
TimeoutStrategy = taskEntity.TimeoutStrategy,
|
||
|
||
IsBatchAudit = taskEntity.IsBatchAudit,
|
||
ProcessUserId = iWFEngine.CreateUser.Id,
|
||
ProcessUserName = iWFEngine.CreateUser.Name,
|
||
ProcessCode = iWFEngine.Config.Params.SchemeCode,
|
||
ProcessTitle = iWFEngine.Config.Params.Title,
|
||
CreateDate = DateTime.Now,
|
||
CreateUserId = _auth.GetUserId(),
|
||
CreateUserName = _auth.GetUserName(),
|
||
IsLast=1,
|
||
IsRetract=1
|
||
};
|
||
await uwo.WFTask.InsertAsync(newTask);
|
||
|
||
// 更新上一个流转过来的任务，提示他无法被撤销
|
||
await CloseTaskLogCancel(taskEntity.ProcessId, taskEntity.PrevTaskId);
|
||
|
||
// 关闭同一个节点，其他人的任务
|
||
await CloseTask(taskEntity.ProcessId, taskEntity.Token, taskEntity.Id);
|
||
|
||
myTaskList = await ExecuteWFTaskEntity(taskList, iWFEngine, taskEntity.ProcessId, taskEntity.Token, taskEntity.Id);
|
||
foreach (var item in myTaskList)
|
||
{
|
||
if (item.Type == 7)
|
||
{
|
||
await uwo.WFTaskUser.InsertRangeAsync(item.WFTaskUser);
|
||
}
|
||
await Add(item);
|
||
}
|
||
|
||
await CreateTaskLog(taskEntity, code, name, des, stampImg);
|
||
|
||
uwo.Commit();
|
||
}
|
||
|
||
|
||
// 脚本执行
|
||
var scriptTaskList = myTaskList.FindAll(t => t.Type == 10);
|
||
foreach (var item in scriptTaskList)
|
||
{
|
||
await ExecuteScript(item, code, taskEntity.ProcessId, taskEntity.Id, nextId, iWFEngine.CreateUser, iWFEngine, taskEntity, des);
|
||
}
|
||
}
|
||
|
||
|
||
#endregion
|
||
}
|
||
}
|