DigitalScholl/Learun.Framework.Ultimate V7/Learun.Framework.Module/Learun.Application.Module/Learun.Application.WorkFlow/Process/NWFProcessSerivce.cs

using Learun.DataBase.Repository;
using Learun.Util;
using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using Learun.Application.TwoDevelopment.LR_LGManager;
using Learun.Application.Organization;
using Dapper;
using Learun.Application.Organization;
using System.Collections.Concurrent;
using System.Threading.Tasks;
using System.Threading;

namespace Learun.Application.WorkFlow
{
    /// <summary>
    /// 版 本 Learun-ADMS V7.0.3 力软敏捷开发框架
    /// Copyright (c) 2013-2018 上海力软信息技术有限公司
    /// 创建人：力软-框架开发组
    /// 日 期：2018.12.07
    /// 描 述：流程进程
    /// </summary>
    public class NWFProcessSericve : RepositoryFactory
    {
        #region 获取数据
        /// <summary>
        /// 获取流程进程实体
        /// </summary>
        /// <param name="keyValue">主键</param>
        /// <returns></returns>
        public NWFProcessEntity GetEntity(string keyValue)
        {
            try
            {
                return this.BaseRepository().FindEntity<NWFProcessEntity>(keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取流程进程实例
        /// </summary>
        /// <param name="processId">父流程进程主键</param>
        /// <param name="nodeId">节点主键</param>
        /// <returns></returns>
        public NWFProcessEntity GetEntityByProcessId(string processId, string nodeId)
        {
            try
            {
                return this.BaseRepository().FindEntity<NWFProcessEntity>(t => t.F_ParentProcessId == processId && t.F_ParentNodeId == nodeId);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取子流程列表
        /// </summary>
        /// <param name="parentProcessId">父流程进程主键</param>
        /// <returns></returns>
        public IEnumerable<NWFProcessEntity> GetChildProcessList(string parentProcessId)
        {
            try
            {
                return this.BaseRepository().FindList<NWFProcessEntity>(t => t.F_ParentProcessId == parentProcessId);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 获取流程信息列表
        /// </summary>
        /// <param name="pagination">分页参数</param>
        /// <param name="queryJson">查询条件</param>
        /// <returns></returns>
        public IEnumerable<NWFProcessEntity> GetPageList(Pagination pagination, string queryJson)
        {
            try
            {
                var expression = LinqExtensions.True<NWFProcessEntity>();
                var queryParam = queryJson.ToJObject();
                // 分类
                if (!queryParam["categoryId"].IsEmpty()) // 1:未完成 2:已完成
                {
                    if (queryParam["categoryId"].ToString() == "1")
                    {
                        expression = expression.And(t => t.F_IsFinished == 0);
                    }
                    else
                    {
                        expression = expression.And(t => t.F_IsFinished == 1);
                    }
                }
                //流程类别
                if (!queryParam["F_Category"].IsEmpty()) // 1:未完成 2:已完成
                {
                    var Categofy = queryParam["F_Category"].ToString();
                    var codeList = this.BaseRepository().FindList<NWFSchemeInfoEntity>(a => a.F_Category == Categofy).Select(a => a.F_Code);

                    if (codeList.Count() > 0)
                    {
                        expression = expression.And(a => codeList.Contains(a.F_SchemeCode));
                    }
                }
                // 操作时间
                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    DateTime startTime = queryParam["StartTime"].ToDate();
                    DateTime endTime = queryParam["EndTime"].ToDate();
                    expression = expression.And(t => t.F_CreateDate >= startTime && t.F_CreateDate <= endTime);
                }
                // 关键字
                if (!queryParam["keyword"].IsEmpty())
                {
                    string keyword = queryParam["keyword"].ToString();
                    expression = expression.And(t => t.F_Title.Contains(keyword) || t.F_SchemeName.Contains(keyword) || t.F_CreateUserName.Contains(keyword));
                }
                // 状态
                if (!queryParam["F_EnabledMark"].IsEmpty()) // 1:未完成 2:已完成
                {
                    if (queryParam["F_EnabledMark"].ToString() == "1")
                    {
                        //运行中
                        expression = expression.And(t => t.F_EnabledMark == 1);
                    }
                    else if (queryParam["F_EnabledMark"].ToString() == "2")
                    {
                        //作废
                        expression = expression.And(t => t.F_EnabledMark != 1);
                    }
                    else if (queryParam["F_EnabledMark"].ToString() == "3")
                    {
                        //结束 已完成
                        expression = expression.And(t => t.F_IsFinished == 1);
                    }
                }
                expression = expression.And(t => t.F_EnabledMark != 2);
                ////20221125增加作废不显示liang
                //expression = expression.And(t => t.F_EnabledMark != 3);
                expression = expression.And(t => t.F_IsChild == 0);

                var result = this.BaseRepository().FindList<NWFProcessEntity>(expression, pagination);
                if (result.Count()>0 )
                {
                    foreach (var item in result)
                    {
                        if (!string.IsNullOrEmpty(item.F_CreateUserName))
                        {
                            item.F_DepartmentId = this.BaseRepository().FindEntity<UserEntity>(x => x.F_UserId == item.F_CreateUserId)?.F_DepartmentId;
                        }
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 获取流程信息列表
        /// </summary>
        /// <param name="pagination">分页参数</param>
        /// <param name="queryJson">查询条件</param>
        /// <returns></returns>
        public IEnumerable<LC_gcsqEntity> GetUseCar(Pagination pagination, string queryJson)
        {
            try
            {
                var queryParam = queryJson.ToJObject();
                var dbName = this.BaseRepository().getDbConnection().Database;
                var dbMISName = this.BaseRepository("CollegeMIS").getDbConnection().Database;
                var dp = new DynamicParameters(new { });
                var strSql = new StringBuilder();
                strSql.Append(" select zb.*,lnp.* from " + dbMISName + ".[dbo].LC_gcsq zb ");
                strSql.Append(" left join  " + dbName + ".[dbo].LR_NWF_PROCESS lnp on  lnp.F_id=zb.LC_ID ");
                strSql.Append(" where 1=1 and lnp.F_SchemeCode = 'LC_gcsq' ");
                strSql.Append(" and lnp.F_EnabledMark != '3' and lnp.F_EnabledMark != '2' and lnp.F_IsChild='0' ");
                if (queryParam["categoryId"].ToString() == "1")
                {
                    strSql.Append("  and lnp.F_IsFinished= '0' ");
                }
                else
                {
                    strSql.Append("  and lnp.F_IsFinished= '1' ");
                }
                if (!queryParam["LC_ycbm"].IsEmpty())
                {
                    strSql.Append(" and zb.LC_ycbm like '%" + queryParam["LC_ycbm"].ToString() + "%' ");
                }
                if (!queryParam["LC_ycr"].IsEmpty())
                {
                    strSql.Append(" and zb.LC_ycr like '%" + queryParam["LC_ycr"].ToString() + "%' ");
                }
                if (!queryParam["LC_ycsj"].IsEmpty())
                {
                    strSql.Append(" and zb.LC_ycsj like '%" + queryParam["LC_ycsj"].ToString() + "%' ");
                }
                if (!queryParam["LC_sjxm"].IsEmpty())
                {
                    strSql.Append(" and zb.LC_sjxm like '%" + queryParam["LC_sjxm"].ToString() + "%' ");
                }
                if (!queryParam["LC_cph"].IsEmpty())
                {
                    strSql.Append(" and zb.LC_cph like '%" + queryParam["LC_cph"].ToString() + "%' ");
                }
                return this.BaseRepository("CollegeMIS").FindList<LC_gcsqEntity>(strSql.ToString(), dp);

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 获取流程信息列表
        /// </summary>
        /// <param name="pagination">分页参数</param>
        /// <param name="queryJson">查询条件</param>
        /// <returns></returns>
        public IEnumerable<cs_qjEntity> GetLeaveStatistics(Pagination pagination, string queryJson)
        {
            try
            {
                var queryParam = queryJson.ToJObject();
                var dbName = this.BaseRepository().getDbConnection().Database;
                var dbMISName = this.BaseRepository("CollegeMIS").getDbConnection().Database;
                var dp = new DynamicParameters(new { });
                var strSql = new StringBuilder();
                strSql.Append(" select zb.*,lnp.* from " + dbMISName + ".[dbo].cs_qj zb ");
                strSql.Append(" left join  " + dbName + ".[dbo].LR_NWF_PROCESS lnp on zb.LC_ID =lnp.F_id ");
                strSql.Append(" where 1=1 and lnp.F_SchemeCode = 'LC_leave'");
                strSql.Append(" and lnp.F_EnabledMark != '3' and lnp.F_EnabledMark != '2' and lnp.F_IsChild='0' ");
                if (queryParam["categoryId"].ToString() == "1")
                {
                    strSql.Append("  and lnp.F_IsFinished= '0' ");
                }
                else
                {
                    strSql.Append("  and lnp.F_IsFinished= '1' ");
                }

                if (!queryParam["qj_name"].IsEmpty())
                {
                    strSql.Append(" and zb.qj_name = '" + queryParam["qj_name"].ToString() + "' ");
                }
                if (!queryParam["qj_bm"].IsEmpty())
                {
                    strSql.Append(" and zb.qj_bm like '%" + queryParam["qj_bm"].ToString() + "%' ");
                }
                if (!queryParam["qj_lx"].IsEmpty())
                {
                    strSql.Append(" and zb.qj_lx = '" + queryParam["qj_lx"].ToString() + "' ");
                }
                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    DateTime startTime = queryParam["StartTime"].ToDate();
                    DateTime endTime = queryParam["EndTime"].ToDate();
                    strSql.Append(" and (  zb.qj_txsj>= '" + startTime + "' and zb.qj_txsj <= '" + endTime + "' )");
                }
                return this.BaseRepository("CollegeMIS").FindList<cs_qjEntity>(strSql.ToString(), dp, pagination);

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取流程信息列表
        /// </summary>
        /// <param name="pagination">分页参数</param>
        /// <param name="queryJson">查询条件</param>
        /// <returns></returns>
        public IEnumerable<LC_docx2Entity> GetTransceiver(Pagination pagination, string queryJson)
        {
            try
            {
                var queryParam = queryJson.ToJObject();
                var dbName = this.BaseRepository().getDbConnection().Database;
                var dbMISName = this.BaseRepository("CollegeMIS").getDbConnection().Database;
                var dp = new DynamicParameters(new { });
                var strSql = new StringBuilder();
                strSql.Append(" select LC_ID,  LC_party, LC_accept, LC_amount, LC_num, LC_numdoc, LC_name, LC_important, LC_secret, LC_docx, LC_other, LC_docx2, LC_docx3, LC_docx4, LC_docx5,lnp.* from " + dbMISName + ".[dbo].LC_docx2 zb ");
                strSql.Append(" left join  " + dbName + ".[dbo].LR_NWF_PROCESS lnp on zb.LC_ID =lnp.F_id ");
                strSql.Append(" where 1=1 and lnp.F_SchemeCode = 'LC_docx' ");
                strSql.Append(" and lnp.F_EnabledMark != '3' and lnp.F_EnabledMark != '2' and lnp.F_IsChild='0' ");
                if (queryParam["categoryId"].ToString() == "1")
                {
                    strSql.Append("  and lnp.F_IsFinished= '0' ");
                }
                else
                {
                    strSql.Append("  and lnp.F_IsFinished= '1' ");
                }
                if (!queryParam["LC_party"].IsEmpty())
                {
                    strSql.Append(" and zb.LC_party like '%" + queryParam["LC_party"].ToString() + "%' ");
                }
                if (!queryParam["LC_name"].IsEmpty())
                {
                    strSql.Append(" and zb.LC_name like '%" + queryParam["LC_name"].ToString() + "%' ");
                }
                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    DateTime startTime = queryParam["StartTime"].ToDate();
                    DateTime endTime = queryParam["EndTime"].ToDate();
                    strSql.Append(" and CONVERT(varchar, zb.lc_accept) >= CONVERT(varchar, '" + startTime + "') and CONVERT(varchar, zb.LC_accept) <= CONVERT(varchar, '" + endTime + "')");
                }
                return this.BaseRepository("CollegeMIS").FindList<LC_docx2Entity>(strSql.ToString(), dp, pagination);

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 根据processid 获取taskid
        /// </summary>
        /// <param name="processId">流程id</param>
        /// <returns></returns>
        public string GetFirstTaskByProcessId(string processId)
        {
            try
            {
                return this.BaseRepository().FindList<NWFTaskEntity>(a => a.F_ProcessId == processId).OrderBy(a => a.F_ModifyDate).FirstOrDefault()?.F_Id;

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取流程信息列表
        /// </summary>
        /// <param name="pagination">分页参数</param>
        /// <param name="queryJson">查询条件</param>
        /// <returns></returns>
        public IEnumerable<NWFProcessEntity> GetAllList()
        {
            try
            {
                return this.BaseRepository().FindList<NWFProcessEntity>();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        public LC_hetongEntity GetHTInfo(string keyValue)
        {
            try
            {
                return this.BaseRepository("CollegeMIS").FindEntity<LC_hetongEntity>(a => a.LC_ID == keyValue);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取我的流程信息列表
        /// </summary>
        /// <param name="userId">用户主键</param>
        /// <param name="pagination">分页参数</param>
        /// <param name="queryJson">查询条件</param>
        /// <param name="schemeCode">流程模板编码</param>
        /// <returns></returns>
        public IEnumerable<NWFProcessEntity> GetMyPageList(string userId, Pagination pagination, string queryJson, string schemeCode)
        {
            try
            {
                var expression = LinqExtensions.True<NWFProcessEntity>();
                var queryParam = queryJson.ToJObject();
                expression = expression.And(t => t.F_CreateUserId == userId);
                // 操作时间
                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    DateTime startTime = queryParam["StartTime"].ToDate();
                    DateTime endTime = queryParam["EndTime"].ToDate();
                    expression = expression.And(t => t.F_CreateDate >= startTime && t.F_CreateDate <= endTime);
                }
                // 关键字
                if (!queryParam["keyword"].IsEmpty())
                {
                    string keyword = queryParam["keyword"].ToString();
                    expression = expression.And(t => t.F_Title.Contains(keyword) || t.F_SchemeName.Contains(keyword));
                }
                if (!string.IsNullOrEmpty(schemeCode))
                {
                    expression = expression.And(t => t.F_SchemeCode.Equals(schemeCode));
                }
                expression = expression.And(t => t.F_IsChild == 0);
                var aa = this.BaseRepository().FindList<NWFProcessEntity>(expression, pagination);
                foreach (var item in aa)
                {
                    item.F_TaskId = this.BaseRepository().FindEntity<NWFTaskEntity>(x => x.F_ProcessId == item.F_Id)?.F_Id;
                    item.F_TaskType = this.BaseRepository().FindEntity<NWFTaskEntity>(x => x.F_ProcessId == item.F_Id)?.F_Type;
                    item.F_TaskName = this.BaseRepository().FindEntity<NWFTaskEntity>(x => x.F_ProcessId == item.F_Id)?.F_NodeName;
                    if (!string.IsNullOrEmpty(item.F_CreateUserName))
                    {
                        item.F_DepartmentId = this.BaseRepository().FindEntity<UserEntity>(x => x.F_UserId == item.F_CreateUserId)?.F_DepartmentId;
                    }
                    //合同流程审批专用  如果第一步校长审批同意的话 可以打印授权委托书
                    if (item.F_SchemeCode == "LC_Contract_")
                    {
                        var entity = this.BaseRepository().FindEntity<NWFTaskLogEntity>(a =>
                              a.F_ProcessId == item.F_Id && a.F_TaskUserId == "29add015-3638-415d-9f91-5024bd746fb5" &&
                              a.F_OperationCode == "agree");
                        if (null != entity)
                        {
                            item.LeaderIsAgree = true;
                        }
                    }
                }
                return aa;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取我的流程信息列表
        /// </summary>
        /// <param name="userId">用户主键</param>
        /// <param name="pagination">分页参数</param>
        /// <param name="schemeCode">流程模板编码</param>
        /// <returns></returns>
        public IEnumerable<NWFProcessEntity> GetMyPageList(string userId, string queryJson, string schemeCode)
        {
            try
            {
                var expression = LinqExtensions.True<NWFProcessEntity>();
                var queryParam = queryJson.ToJObject();
                expression = expression.And(t => t.F_CreateUserId == userId);
                // 操作时间
                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    DateTime startTime = queryParam["StartTime"].ToDate();
                    DateTime endTime = queryParam["EndTime"].ToDate();
                    expression = expression.And(t => t.F_CreateDate >= startTime && t.F_CreateDate <= endTime);
                }
                // 关键字
                if (!queryParam["keyword"].IsEmpty())
                {
                    string keyword = queryParam["keyword"].ToString();
                    expression = expression.And(t => t.F_Title.Contains(keyword) || t.F_SchemeName.Contains(keyword));
                }
                if (!string.IsNullOrEmpty(schemeCode))
                {
                    expression = expression.And(t => t.F_SchemeCode.Equals(schemeCode));
                }
                expression = expression.And(t => t.F_IsChild == 0);
                return this.BaseRepository().FindList<NWFProcessEntity>(expression);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取我的代办任务列表
        /// </summary>
        /// <param name="userInfo">用户信息</param>
        /// <param name="pagination">翻页信息</param>
        /// <param name="queryJson">查询条件</param>
        /// <param name="schemeCode">流程模板编码</param>
        /// <param name="isBatchAudit">true获取批量审核任务</param>
        /// <returns></returns>
        public IEnumerable<NWFProcessEntity> GetMyTaskPageList(UserInfo userInfo, Pagination pagination, string queryJson, string schemeCode, bool isBatchAudit = false)
        {
            try
            {
                string userId = userInfo.userId;
                var strSql = new StringBuilder();
                strSql.Append(@"SELECT
	                                t.F_Id AS F_TaskId,
	                                t.F_Type AS F_TaskType,
	                                t.F_NodeName AS F_TaskName,
                                    t.F_IsUrge,
                                    t.F_ModifyDate as F_CreateDate,
                                    p.F_Id,
                                    p.F_SchemeId,
                                    p.F_SchemeCode,
                                    p.F_SchemeName,
                                    p.F_Title,
                                    p.F_Level,
                                    p.F_EnabledMark,
                                    p.F_IsAgain,
                                    p.F_IsFinished,
                                    p.F_IsChild,
                                    p.F_ParentTaskId,
                                    p.F_ParentProcessId,
                                    p.F_CreateUserId,
                                    p.F_CreateUserName,
                                    p.F_IsStart,
                                    d.F_DepartmentId,d.F_FullName
                                FROM
	                                (
		                                SELECT
			                                F_TaskId
		                                FROM
			                                LR_NWF_TaskRelation r1
                                        LEFT JOIN LR_NWF_Task t1 ON r1.F_TaskId = t1.F_Id 
                                        WHERE r1.F_Mark = 0 AND r1.F_Result = 0 AND (r1.F_UserId  = @userId 
		                               ");


                // 添加委托信息
                List<UserInfo> delegateList = GetDelegateProcess(userId);
                foreach (var item in delegateList)
                {
                    string processId = "'" + item.wfProcessId.Replace(",", "','") + "'";
                    string userI2 = "'" + item.userId + "'";

                    strSql.Append("  OR (r1.F_UserId =" + userI2 + " AND t1.F_ProcessId in (" + processId + ") AND t1.F_Type != 2 )");
                }
                strSql.Append(@") GROUP BY
			                                F_TaskId
	                                ) r
                                LEFT JOIN LR_NWF_Task t ON t.F_Id = r.F_TaskId
                                LEFT JOIN LR_NWF_Process p ON p.F_Id = t.F_ProcessId
                                LEFT JOIN(
	                                SELECT t.F_DepartmentId,t.F_FullName,u.F_RealName,u.F_UserId 
	                                FROM LR_Base_Department t left join LR_BASE_USER u on t.F_DepartmentId = u.F_DepartmentId) d ON d.F_UserId=t.F_CreateUserId
                                WHERE
	                                t.F_IsFinished = 0  AND (p.F_IsFinished = 0 OR t.F_Type = 2 OR t.F_Type = 4 OR t.F_Type = 6)");

                var queryParam = queryJson.ToJObject();
                DateTime startTime = DateTime.Now, endTime = DateTime.Now;

                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    startTime = queryParam["StartTime"].ToDate();
                    endTime = queryParam["EndTime"].ToDate();
                    strSql.Append(" AND ( t.F_ModifyDate >= @startTime AND  t.F_ModifyDate <= @endTime ) ");
                }
                string keyword = "";
                if (!queryParam["keyword"].IsEmpty())
                {
                    keyword = "%" + queryParam["keyword"].ToString() + "%";
                    strSql.Append(" AND ( p.F_Title like @keyword OR  p.F_SchemeName like @keyword  OR p.F_CreateUserName like @keyword OR d.F_FullName like @keyword ) ");
                }

                if (!string.IsNullOrEmpty(schemeCode))
                {
                    strSql.Append(" AND p.F_SchemeCode = @schemeCode ");
                }

                if (isBatchAudit)
                {
                    strSql.Append(" AND t.F_IsBatchAudit = 1 ");
                }
                var data = this.BaseRepository().FindList<NWFProcessEntity>(strSql.ToString(), new { userId, startTime, endTime, keyword, schemeCode }, pagination);
                //if (data.Count() > 0)
                //{
                //    foreach (var item in data)
                //    {
                //        if (!string.IsNullOrEmpty(item.F_CreateUserName))
                //        {
                //            item.F_DepartmentId = this.BaseRepository().FindEntity<UserEntity>(x => x.F_UserId == item.F_CreateUserId)?.F_DepartmentId;
                //        }
                //    }
                //}
                return data;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取我的代办任务列表
        /// </summary>
        /// <param name="userInfo">用户信息</param>
        /// <param name="queryJson">查询条件</param>
        /// <param name="schemeCode">流程模板编码</param>
        /// <param name="isBatchAudit">true获取批量审核任务</param>
        /// <returns></returns>
        public IEnumerable<NWFProcessEntity> GetMyTaskPageList(UserInfo userInfo, string queryJson, string schemeCode, bool isBatchAudit = false)
        {
            try
            {
                string userId = userInfo.userId;
                var strSql = new StringBuilder();
                strSql.Append(@"SELECT
	                                t.F_Id AS F_TaskId,
	                                t.F_Type AS F_TaskType,
	                                t.F_NodeName AS F_TaskName,
                                    t.F_IsUrge,
                                    t.F_ModifyDate as F_CreateDate,
                                    p.F_Id,
                                    p.F_SchemeId,
                                    p.F_SchemeCode,
                                    p.F_SchemeName,
                                    p.F_Title,
                                    p.F_Level,
                                    p.F_EnabledMark,
                                    p.F_IsAgain,
                                    p.F_IsFinished,
                                    p.F_IsChild,
                                    p.F_ParentTaskId,
                                    p.F_ParentProcessId,
                                    p.F_CreateUserId,
                                    p.F_CreateUserName,
                                    p.F_IsStart
                                FROM
	                                (
		                                SELECT
			                                F_TaskId
		                                FROM
			                                LR_NWF_TaskRelation r1
                                        LEFT JOIN LR_NWF_Task t1 ON r1.F_TaskId = t1.F_Id 
                                        WHERE r1.F_Mark = 0 AND r1.F_Result = 0 AND (r1.F_UserId  = @userId 
		                               ");


                // 添加委托信息
                List<UserInfo> delegateList = GetDelegateProcess(userId);
                foreach (var item in delegateList)
                {
                    string processId = "'" + item.wfProcessId.Replace(",", "','") + "'";
                    string userI2 = "'" + item.userId + "'";

                    strSql.Append("  OR (r1.F_UserId =" + userI2 + " AND t1.F_ProcessId in (" + processId + ") AND t1.F_Type != 2 )");
                }
                strSql.Append(@") GROUP BY
			                                F_TaskId
	                                ) r
                                LEFT JOIN LR_NWF_Task t ON t.F_Id = r.F_TaskId
                                LEFT JOIN LR_NWF_Process p ON p.F_Id = t.F_ProcessId
                                WHERE
	                                t.F_IsFinished = 0  AND (p.F_IsFinished = 0 OR t.F_Type = 2 OR t.F_Type = 4 OR t.F_Type = 6)");

                var queryParam = queryJson.ToJObject();
                DateTime startTime = DateTime.Now, endTime = DateTime.Now;

                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    startTime = queryParam["StartTime"].ToDate();
                    endTime = queryParam["EndTime"].ToDate();
                    strSql.Append(" AND ( t.F_ModifyDate >= @startTime AND  t.F_ModifyDate <= @endTime ) ");
                }
                string keyword = "";
                if (!queryParam["keyword"].IsEmpty())
                {
                    keyword = "%" + queryParam["keyword"].ToString() + "%";
                    strSql.Append(" AND ( p.F_Title like @keyword OR  p.F_SchemeName like @keyword ) ");
                }

                if (!string.IsNullOrEmpty(schemeCode))
                {
                    strSql.Append(" AND p.F_SchemeCode = @schemeCode ");
                }

                if (isBatchAudit)
                {
                    strSql.Append(" AND t.F_IsBatchAudit = 1 ");
                }

                return this.BaseRepository().FindList<NWFProcessEntity>(strSql.ToString(), new { userId, startTime, endTime, keyword, schemeCode });
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取我的已办任务列表
        /// </summary>
        /// <param name="userId">用户主键</param>
        /// <param name="pagination">翻页信息</param>
        /// <param name="queryJson">查询条件</param>
        /// <param name="schemeCode">流程模板编码</param>
        /// <returns></returns>
        public IEnumerable<NWFProcessEntity> GetMyFinishTaskPageList(UserInfo userInfo, Pagination pagination, string queryJson, string schemeCode)
        {
            try
            {
                var strSql = new StringBuilder();
                strSql.Append(@"SELECT
	                                t.F_Id AS F_TaskId,
	                                t.F_Type AS F_TaskType,
	                                t.F_NodeName AS F_TaskName,
	                                r.F_Time as F_CreateDate,
                                    p.F_Id,
                                    p.F_SchemeId,
                                    p.F_SchemeCode,
                                    p.F_SchemeName,
                                    p.F_Title,
                                    p.F_Level,
                                    p.F_EnabledMark,
                                    p.F_IsAgain,
                                    p.F_IsFinished,
                                    p.F_IsChild,
                                    p.F_ParentTaskId,
                                    p.F_ParentProcessId,
                                    p.F_CreateUserId,
                                    p.F_CreateUserName,
                                    p.F_IsStart,
                                    t.F_NodeId,
                                    d.F_DepartmentId,d.F_FullName
                                FROM
	                                LR_NWF_Task t
                                LEFT JOIN LR_NWF_TaskRelation r on r.F_TaskId = t.F_Id
                                LEFT JOIN LR_NWF_Process p ON t.F_ProcessId = p.F_Id
                                LEFT JOIN(
	                                SELECT t.F_DepartmentId,t.F_FullName,u.F_RealName,u.F_UserId 
	                                FROM LR_Base_Department t 
                                        left join LR_BASE_USER u on t.F_DepartmentId = u.F_DepartmentId
                                        ) d ON d.F_UserId=t.F_CreateUserId
                                WHERE
	                                (r.F_Result = 1 OR  r.F_Result = 2  OR  r.F_Result = 4) AND  r.F_UserId = @userId 
                ");


                var queryParam = queryJson.ToJObject();
                DateTime startTime = DateTime.Now, endTime = DateTime.Now;

                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    startTime = queryParam["StartTime"].ToDate();
                    endTime = queryParam["EndTime"].ToDate();
                    strSql.Append(" AND ( r.F_Time >= @startTime AND  r.F_Time <= @endTime ) ");
                }
                string keyword = "";
                if (!queryParam["keyword"].IsEmpty())
                {
                    keyword = "%" + queryParam["keyword"].ToString() + "%";
                    strSql.Append(" AND ( p.F_Title like @keyword OR  p.F_SchemeName like @keyword OR p.F_CreateUserName like @keyword  OR p.F_CreateUserName like @keyword OR d.F_FullName like @keyword) ");
                }
                if (!string.IsNullOrEmpty(schemeCode))
                {
                    strSql.Append(" AND p.F_SchemeCode = @schemeCode ");
                }

                var data = this.BaseRepository().FindList<NWFProcessEntity>(strSql.ToString(), new { userInfo.userId, startTime, endTime, keyword, schemeCode }, pagination);
                foreach (var item in data)
                {
                    var nextNode = this.BaseRepository().FindEntity<NWFTaskLogEntity>(a =>
                         a.F_ProcessId == item.F_Id && a.F_PrevNodeId == item.F_NodeId);
                    if (null != nextNode)
                    {
                        item.NextNodeIsAudited = true;
                    }
                    //if (!string.IsNullOrEmpty(item.F_CreateUserName))
                    //{
                    //    item.F_DepartmentId = this.BaseRepository().FindEntity<UserEntity>(x => x.F_UserId == item.F_CreateUserId)?.F_DepartmentId;
                    //}
                }
                return data;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取我的已办任务列表
        /// </summary>
        /// <param name="userId">用户主键</param>
        /// <param name="queryJson">查询条件</param>
        /// <param name="schemeCode">流程模板编码</param>
        /// <returns></returns>
        public IEnumerable<NWFProcessEntity> GetMyFinishTaskPageList(UserInfo userInfo, string queryJson, string schemeCode)
        {
            try
            {
                var strSql = new StringBuilder();
                strSql.Append(@"SELECT
	                                t.F_Id AS F_TaskId,
	                                t.F_Type AS F_TaskType,
	                                t.F_NodeName AS F_TaskName,
	                                r.F_Time as F_CreateDate,
                                    p.F_Id,
                                    p.F_SchemeId,
                                    p.F_SchemeCode,
                                    p.F_SchemeName,
                                    p.F_Title,
                                    p.F_Level,
                                    p.F_EnabledMark,
                                    p.F_IsAgain,
                                    p.F_IsFinished,
                                    p.F_IsChild,
                                    p.F_ParentTaskId,
                                    p.F_ParentProcessId,
                                    p.F_CreateUserId,
                                    p.F_CreateUserName,
                                    p.F_IsStart
                                FROM
	                                LR_NWF_Task t
                                LEFT JOIN LR_NWF_TaskRelation r on r.F_TaskId = t.F_Id
                                LEFT JOIN LR_NWF_Process p ON t.F_ProcessId = p.F_Id
                                WHERE
	                                (r.F_Result = 1 OR  r.F_Result = 2  OR  r.F_Result = 4) AND  r.F_UserId = @userId 
                ");


                var queryParam = queryJson.ToJObject();
                DateTime startTime = DateTime.Now, endTime = DateTime.Now;

                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    startTime = queryParam["StartTime"].ToDate();
                    endTime = queryParam["EndTime"].ToDate();
                    strSql.Append(" AND ( r.F_Time >= @startTime AND  r.F_Time <= @endTime ) ");
                }
                string keyword = "";
                if (!queryParam["keyword"].IsEmpty())
                {
                    keyword = "%" + queryParam["keyword"].ToString() + "%";
                    strSql.Append(" AND ( p.F_ProcessName like @keyword OR  p.F_SchemeName like @keyword ) ");
                }
                if (!string.IsNullOrEmpty(schemeCode))
                {
                    strSql.Append(" AND p.F_SchemeCode = @schemeCode ");
                }

                return this.BaseRepository().FindList<NWFProcessEntity>(strSql.ToString(), new { userInfo.userId, startTime, endTime, keyword, schemeCode });
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取委托人关联的流程进程列表
        /// </summary>
        /// <param name="userId">当前用户主键</param>
        /// <returns></returns>
        public List<UserInfo> GetDelegateProcess(string userId)
        {
            try
            {
                List<UserInfo> delegateUserlist = new List<UserInfo>();
                DateTime datatime = DateTime.Now;
                IEnumerable<NWFDelegateRuleEntity> wfDelegateRuleList = this.BaseRepository().FindList<NWFDelegateRuleEntity>(t => t.F_ToUserId == userId && t.F_BeginDate <= datatime && t.F_EndDate >= datatime);
                foreach (var item in wfDelegateRuleList)
                {
                    UserInfo userinfo = new UserInfo();
                    userinfo.userId = item.F_CreateUserId;

                    var strSql = new StringBuilder();
                    strSql.Append(@"SELECT
	                                    p.F_Id
                                    FROM
	                                    LR_NWF_DelegateRelation d
                                    LEFT JOIN LR_NWF_SchemeInfo s ON s.F_Id = d.F_SchemeInfoId
                                    LEFT JOIN LR_NWF_Process p ON p.F_SchemeCode = s.F_Code
                                    WHERE
	                                    p.F_Id IS NOT NULL
                                    AND p.F_IsFinished = 0
                                    AND d.F_DelegateRuleId = @DelegateRuleId ");

                    DataTable dt = this.BaseRepository().FindTable(strSql.ToString(), new { DelegateRuleId = item.F_Id });
                    userinfo.wfProcessId = "";
                    foreach (DataRow dr in dt.Rows)
                    {
                        if (!string.IsNullOrEmpty(dr[0].ToString()))
                        {
                            if (!string.IsNullOrEmpty(userinfo.wfProcessId))
                            {
                                userinfo.wfProcessId += ",";
                            }
                            userinfo.wfProcessId += dr[0].ToString();
                        }
                    }

                    if (!string.IsNullOrEmpty(userinfo.wfProcessId))
                    {
                        delegateUserlist.Add(userinfo);
                    }
                }
                return delegateUserlist;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        #region 流程表单数据统计

        /// <summary>
        /// 用印申请流程表单统计
        /// </summary>
        /// <param name="pagination">分页参数</param>
        /// <param name="queryJson">查询条件</param>
        /// <returns></returns>
        public IEnumerable<LC_yyspdEntity> GetPageListOfyyspd(Pagination pagination, string queryJson)
        {
            try
            {
                var misdbname = BaseRepository("CollegeMIS").getDbConnection().Database;
                var basedbname = BaseRepository().getDbConnection().Database;

                var strSql = new StringBuilder();
                strSql.Append("select y.*,t.F_Id,t.F_SchemeId,t.F_SchemeCode,t.F_SchemeName,t.F_Title,t.F_Level,t.F_EnabledMark,t.F_IsFinished,t.F_CreateDate,t.F_CreateUserId,t.F_CreateUserName as F_CreateUserNameInProcess from LR_NWF_Process t left join LR_NWF_SchemeInfo s on t.F_SchemeCode=s.F_Code ");
                strSql.Append($" left join {misdbname}.dbo.LC_yyspd y on y.LC_ID=t.F_Id ");
                strSql.Append(" where 1=1 and t.F_EnabledMark !=2 and t.F_EnabledMark != 3 and t.F_IsChild = 0 ");
                strSql.Append(" and s.F_Code='LC_yyspd' ");

                var queryParam = queryJson.ToJObject();
                // 虚拟参数
                var dp = new DynamicParameters(new { });

                // 分类
                if (!queryParam["categoryId"].IsEmpty()) // 1:未完成 2:已完成
                {
                    if (queryParam["categoryId"].ToString() == "1")
                    {
                        strSql.Append(" and t.F_IsFinished = 0 ");
                    }
                    else
                    {
                        strSql.Append(" and t.F_IsFinished = 1 ");
                    }
                }
                //用印名称
                if (!queryParam["LC_yzmc"].IsEmpty())
                {
                    dp.Add("LC_yzmc", "%" + queryParam["LC_yzmc"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_yzmc like @LC_yzmc ");
                }
                //用印事项
                if (!queryParam["LC_yysx"].IsEmpty())
                {
                    dp.Add("LC_yysx", "%" + queryParam["LC_yysx"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_yysx like @LC_yysx ");
                }
                //用印时间
                if (!queryParam["LC_yysj"].IsEmpty())
                {
                    dp.Add("LC_yysj", "%" + queryParam["LC_yysj"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_yysj like @LC_yysj ");
                }
                //关键字：用印名称、用印事项、用印时间
                if (!queryParam["keyword"].IsEmpty())
                {
                    dp.Add("keyword", "%" + queryParam["keyword"].ToString() + "%", DbType.String);
                    strSql.Append(" AND (y.LC_yzmc like @keyword or y.LC_yysx like @keyword or y.LC_yysj like @keyword) ");
                }
                // 用印时间
                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    dp.Add("StartTime", queryParam["StartTime"].ToString(), DbType.String);
                    dp.Add("EndTime", queryParam["EndTime"].ToString(), DbType.String);
                    strSql.Append(" and (y.LC_yysj >= @StartTime and y.LC_yysj <= @EndTime)");
                }

                var result = this.BaseRepository().FindList<LC_yyspdEntity>(strSql.ToString(), dp);

                return result;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 会议室申请流程表单统计
        /// </summary>
        /// <param name="pagination">分页参数</param>
        /// <param name="queryJson">查询条件</param>
        /// <returns></returns>
        public IEnumerable<LC_meetingEntity> GetPageListOfmeeting(Pagination pagination, string queryJson)
        {
            try
            {
                var misdbname = BaseRepository("CollegeMIS").getDbConnection().Database;
                var basedbname = BaseRepository().getDbConnection().Database;

                var strSql = new StringBuilder();
                strSql.Append("select y.*,t.F_Id,t.F_SchemeId,t.F_SchemeCode,t.F_SchemeName,t.F_Title,t.F_Level,t.F_EnabledMark,t.F_IsFinished,t.F_CreateDate,t.F_CreateUserId,t.F_CreateUserName as F_CreateUserNameInProcess from LR_NWF_Process t left join LR_NWF_SchemeInfo s on t.F_SchemeCode=s.F_Code ");
                strSql.Append($" left join {misdbname}.dbo.LC_meeting y on y.LC_ID=t.F_Id ");
                strSql.Append(" where 1=1 and t.F_EnabledMark !=2 and t.F_EnabledMark != 3 and t.F_IsChild = 0 ");
                strSql.Append(" and s.F_Code='LC_meeting' ");

                var queryParam = queryJson.ToJObject();
                // 虚拟参数
                var dp = new DynamicParameters(new { });

                // 分类
                if (!queryParam["categoryId"].IsEmpty()) // 1:未完成 2:已完成
                {
                    if (queryParam["categoryId"].ToString() == "1")
                    {
                        strSql.Append(" and t.F_IsFinished = 0 ");
                    }
                    else
                    {
                        strSql.Append(" and t.F_IsFinished = 1 ");
                    }
                }
                //申请人
                if (!queryParam["F_CreateUserName"].IsEmpty())
                {
                    dp.Add("F_CreateUserName", "%" + queryParam["F_CreateUserName"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.F_CreateUserName like @F_CreateUserName ");
                }
                //会议主题
                if (!queryParam["LC_Title"].IsEmpty())
                {
                    dp.Add("LC_Title", "%" + queryParam["LC_Title"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_Title like @LC_Title ");
                }
                //会议内容
                if (!queryParam["LC_Content"].IsEmpty())
                {
                    dp.Add("LC_Content", "%" + queryParam["LC_Content"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_Content like @LC_Content ");
                }
                //会议室
                if (!queryParam["LC_Meetroom"].IsEmpty())
                {
                    dp.Add("LC_Meetroom", "%" + queryParam["LC_Meetroom"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_Meetroom like @LC_Meetroom ");
                }
                //会议时间
                if (!queryParam["LC_MeetTime"].IsEmpty())
                {
                    dp.Add("LC_MeetTime", "%" + queryParam["LC_MeetTime"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_MeetTime like @LC_MeetTime ");
                }
                //关键字：申请人、会议主题、会议内容、会议室、会议时间
                if (!queryParam["keyword"].IsEmpty())
                {
                    dp.Add("keyword", "%" + queryParam["keyword"].ToString() + "%", DbType.String);
                    strSql.Append(" AND (y.F_CreateUserName like @keyword or y.LC_Title like @keyword or y.LC_Content like @keyword or y.LC_Meetroom like @keyword or y.LC_MeetTime like @keyword) ");
                }
                // 会议时间
                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    dp.Add("StartTime", queryParam["StartTime"].ToString(), DbType.Date);
                    dp.Add("EndTime", queryParam["EndTime"].ToString(), DbType.Date);
                    strSql.Append(" and (y.LC_MeetTime >= @StartTime and y.LC_MeetTime <= @EndTime)");
                }

                var result = this.BaseRepository().FindList<LC_meetingEntity>(strSql.ToString(), dp);

                return result;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 党委会党委专题会申请流程表单统计
        /// </summary>
        /// <param name="pagination">分页参数</param>
        /// <param name="queryJson">查询条件</param>
        /// <returns></returns>
        public IEnumerable<LC_dwhsqEntity> GetPageListOfdwhsq(Pagination pagination, string queryJson)
        {
            try
            {
                var misdbname = BaseRepository("CollegeMIS").getDbConnection().Database;
                var basedbname = BaseRepository().getDbConnection().Database;

                var strSql = new StringBuilder();
                strSql.Append("select y.*,t.F_Id,t.F_SchemeId,t.F_SchemeCode,t.F_SchemeName,t.F_Title,t.F_Level,t.F_EnabledMark,t.F_IsFinished,t.F_CreateDate,t.F_CreateUserId,t.F_CreateUserName as F_CreateUserNameInProcess from LR_NWF_Process t left join LR_NWF_SchemeInfo s on t.F_SchemeCode=s.F_Code ");
                strSql.Append($" left join {misdbname}.dbo.LC_dwhsq y on y.LC_ID=t.F_Id ");
                strSql.Append(" where 1=1 and t.F_EnabledMark !=2 and t.F_EnabledMark != 3 and t.F_IsChild = 0 ");
                strSql.Append(" and s.F_Code='LC_dwhsq' ");

                var queryParam = queryJson.ToJObject();
                // 虚拟参数
                var dp = new DynamicParameters(new { });

                // 分类
                if (!queryParam["categoryId"].IsEmpty()) // 1:未完成 2:已完成
                {
                    if (queryParam["categoryId"].ToString() == "1")
                    {
                        strSql.Append(" and t.F_IsFinished = 0 ");
                    }
                    else
                    {
                        strSql.Append(" and t.F_IsFinished = 1 ");
                    }
                }
                //申请人
                if (!queryParam["F_CreateUserName"].IsEmpty())
                {
                    dp.Add("F_CreateUserName", "%" + queryParam["F_CreateUserName"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.F_CreateUserName like @F_CreateUserName ");
                }
                //会议主题
                if (!queryParam["LC_hyzt"].IsEmpty())
                {
                    dp.Add("LC_hyzt", "%" + queryParam["LC_hyzt"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_hyzt like @LC_hyzt ");
                }
                //会议内容
                if (!queryParam["LC_hynr"].IsEmpty())
                {
                    dp.Add("LC_hynr", "%" + queryParam["LC_hynr"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_hynr like @LC_hynr ");
                }
                //会议时间
                if (!queryParam["LC_hysj"].IsEmpty())
                {
                    dp.Add("LC_hysj", "%" + queryParam["LC_hysj"].ToString() + "%", DbType.String);
                    strSql.Append(" AND y.LC_hysj like @LC_hysj ");
                }
                //关键字：申请人、会议主题、会议内容、会议时间
                if (!queryParam["keyword"].IsEmpty())
                {
                    dp.Add("keyword", "%" + queryParam["keyword"].ToString() + "%", DbType.String);
                    strSql.Append(" AND (y.F_CreateUserName like @keyword or y.LC_hyzt like @keyword or y.LC_hysj like @keyword or y.LC_hynr like @keyword ) ");
                }
                // 会议时间
                if (!queryParam["StartTime"].IsEmpty() && !queryParam["EndTime"].IsEmpty())
                {
                    dp.Add("StartTime", queryParam["StartTime"].ToString(), DbType.Date);
                    dp.Add("EndTime", queryParam["EndTime"].ToString(), DbType.Date);
                    strSql.Append(" and (y.LC_hysj >= @StartTime and y.LC_hysj <= @EndTime)");
                }

                var result = this.BaseRepository().FindList<LC_dwhsqEntity>(strSql.ToString(), dp);

                return result;
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }


        #endregion

        #region 获取sql语句
        /// <summary>
        /// 获取我的流程信息列表SQL语句
        /// </summary>
        /// <returns></returns>
        public string GetMySql()
        {
            try
            {
                var strSql = new StringBuilder();
                strSql.Append(@"SELECT
	                                p.F_CreateDate,
                                    p.F_Id,
                                    p.F_SchemeId,
                                    p.F_SchemeCode,
                                    p.F_SchemeName,
                                    p.F_Title,
                                    p.F_Level,
                                    p.F_EnabledMark,
                                    p.F_IsAgain,
                                    p.F_IsFinished,
                                    p.F_IsChild,
                                    p.F_ParentTaskId,
                                    p.F_ParentProcessId,
                                    p.F_CreateUserId,
                                    p.F_CreateUserName,
                                    p.F_IsStart
                                FROM
	                                LR_NWF_Process p
                                WHERE
	                                p.F_CreateUserId = @userId AND p.F_IsChild = 0
                ");

                return strSql.ToString();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取我的代办任务列表SQL语句
        /// </summary>
        /// <param name="userInfo">用户信息</param>
        /// <param name="isBatchAudit">true获取批量审核任务</param>
        /// <returns></returns>
        public string GetMyTaskSql(UserInfo userInfo, bool isBatchAudit = false)
        {
            try
            {
                var strSql = new StringBuilder();
                strSql.Append(@"SELECT
	                                t.F_Id AS F_TaskId,
	                                t.F_Type AS F_TaskType,
	                                t.F_NodeName AS F_TaskName,
                                    t.F_IsUrge,
                                    t.F_ModifyDate as F_CreateDate,
                                    p.F_Id,
                                    p.F_SchemeId,
                                    p.F_SchemeCode,
                                    p.F_SchemeName,
                                    p.F_Title,
                                    p.F_Level,
                                    p.F_EnabledMark,
                                    p.F_IsAgain,
                                    p.F_IsFinished,
                                    p.F_IsChild,
                                    p.F_ParentTaskId,
                                    p.F_ParentProcessId,
                                    p.F_CreateUserId,
                                    p.F_CreateUserName,
                                    p.F_IsStart
                                FROM
	                                (
		                                SELECT
			                                F_TaskId
		                                FROM
			                                LR_NWF_TaskRelation r1
                                        LEFT JOIN LR_NWF_Task t1 ON r1.F_TaskId = t1.F_Id 
                                        WHERE r1.F_Mark = 0 AND r1.F_Result = 0 AND (r1.F_UserId  = @userId 
		                               ");


                // 添加委托信息
                List<UserInfo> delegateList = GetDelegateProcess(userInfo.userId);
                foreach (var item in delegateList)
                {
                    string processId = "'" + item.wfProcessId.Replace(",", "','") + "'";
                    string userI2 = "'" + item.userId + "'";

                    strSql.Append("  OR (r1.F_UserId =" + userI2 + " AND t1.F_ProcessId in (" + processId + ") AND t1.F_Type != 2 )");
                }
                strSql.Append(@") GROUP BY
			                                F_TaskId
	                                ) r
                                LEFT JOIN LR_NWF_Task t ON t.F_Id = r.F_TaskId
                                LEFT JOIN LR_NWF_Process p ON p.F_Id = t.F_ProcessId
                                WHERE
	                                t.F_IsFinished = 0  AND (p.F_IsFinished = 0 OR t.F_Type = 2)");

                if (isBatchAudit)
                {
                    strSql.Append(" AND t.F_IsBatchAudit = 1 ");
                }

                return strSql.ToString();

            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 获取我的已办任务列表SQL语句
        /// </summary>
        /// <returns></returns>
        public string GetMyFinishTaskSql()
        {
            try
            {
                var strSql = new StringBuilder();
                strSql.Append(@"SELECT
	                                t.F_Id AS F_TaskId,
	                                t.F_Type AS F_TaskType,
	                                t.F_NodeName AS F_TaskName,
	                                r.F_Time as F_CreateDate,
                                    p.F_Id,
                                    p.F_SchemeId,
                                    p.F_SchemeCode,
                                    p.F_SchemeName,
                                    p.F_Title,
                                    p.F_Level,
                                    p.F_EnabledMark,
                                    p.F_IsAgain,
                                    p.F_IsFinished,
                                    p.F_IsChild,
                                    p.F_ParentTaskId,
                                    p.F_ParentProcessId,
                                    p.F_CreateUserId,
                                    p.F_CreateUserName,
                                    p.F_IsStart
                                FROM
	                                LR_NWF_Task t
                                LEFT JOIN LR_NWF_TaskRelation r on r.F_TaskId = t.F_Id
                                LEFT JOIN LR_NWF_Process p ON t.F_ProcessId = p.F_Id
                                WHERE
	                                (r.F_Result = 1 OR  r.F_Result = 2  OR  r.F_Result = 4) AND  r.F_UserId = @userId 
                ");

                return strSql.ToString();
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        #endregion

        #endregion

        #region 保存信息
        /// <summary>
        /// 保存流程进程数据
        /// </summary>
        /// <param name="nWFProcessEntity">流程进程</param>
        /// <param name="taskList">流程任务列表</param>
        /// <param name="taskMsgList">流程消息列表</param>
        /// <param name="taskLogEntity">任务日志</param>
        public void Save(NWFProcessEntity nWFProcessEntity, List<NWFTaskEntity> taskList, List<NWFTaskMsgEntity> taskMsgList, NWFTaskLogEntity taskLogEntity)
        {
            NWFProcessEntity nWFProcessEntityTmp = this.BaseRepository().FindEntity<NWFProcessEntity>(nWFProcessEntity.F_Id);
            var db = this.BaseRepository().BeginTrans();
            try
            {
                if (nWFProcessEntityTmp == null)
                {
                    db.Insert(nWFProcessEntity);
                }
                else
                {
                    db.Update(nWFProcessEntity);
                }
                foreach (var task in taskList)
                {
                    task.F_ModifyDate = DateTime.Now;
                    db.Insert(task);
                    int num = 1;
                    if (task.nWFUserInfoList != null)
                    {
                        foreach (var taskUser in task.nWFUserInfoList)
                        {
                            NWFTaskRelationEntity nWFTaskRelationEntity = new NWFTaskRelationEntity();
                            nWFTaskRelationEntity.Create();
                            nWFTaskRelationEntity.F_TaskId = task.F_Id;
                            nWFTaskRelationEntity.F_UserId = taskUser.Id;
                            nWFTaskRelationEntity.F_Mark = taskUser.Mark;
                            nWFTaskRelationEntity.F_Result = 0;
                            nWFTaskRelationEntity.F_Sort = num;
                            db.Insert(nWFTaskRelationEntity);
                            num++;
                        }
                    }
                }
                foreach (var taskMsg in taskMsgList)
                {
                    db.Insert(taskMsg);
                }

                db.Insert(taskLogEntity);

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 保存流程进程信息
        /// </summary>
        /// <param name="taskLogEntity">任务日志</param>
        /// <param name="taskRelationEntity">任务执行人状态更新</param>
        /// <param name="taskEntityUpdate">任务状态更新</param>
        /// <param name="processEntity">流程进程状态更新</param>
        /// <param name="confluenceList">会签信息</param>
        /// <param name="closeTaskList">会签需要关闭的任务</param>
        /// <param name="taskList">新的任务列表</param>
        /// <param name="taskMsgList">新的任务消息列表</param>
        public void Save(NWFTaskLogEntity taskLogEntity, NWFTaskRelationEntity taskRelationEntity, NWFTaskEntity taskEntityUpdate, NWFProcessEntity processEntity, List<NWFConfluenceEntity> confluenceList, List<NWFTaskEntity> closeTaskList, List<NWFTaskEntity> taskList, List<NWFTaskMsgEntity> taskMsgList, NWFProcessEntity pProcessEntity = null)
        {
            var db = this.BaseRepository().BeginTrans();
            try
            {
                db.Insert(taskLogEntity);
                if (taskRelationEntity != null)
                    db.Update(taskRelationEntity);
                db.Update(taskEntityUpdate);

                if (processEntity != null)
                {
                    db.Update(processEntity);
                }

                if (pProcessEntity != null)
                {
                    db.Update(pProcessEntity);
                }

                if (confluenceList != null)
                {
                    foreach (var item in confluenceList)
                    {
                        if (item.isClear)
                        {
                            string processId = item.F_ProcessId;
                            string nodeId = item.F_NodeId;
                            db.Delete<NWFConfluenceEntity>(t => t.F_ProcessId == processId && t.F_NodeId == nodeId);
                            // 增加一条会签审核记录
                            NWFTaskLogEntity nWFTaskLogEntity = new NWFTaskLogEntity()
                            {
                                F_ProcessId = processId,
                                F_OperationCode = "confluence",
                                F_OperationName = "会签" + (item.confluenceRes == 1 ? "通过" : "不通过"),
                                F_NodeId = item.F_NodeId,
                                F_TaskType = 7
                            };
                            nWFTaskLogEntity.Create();
                            db.Insert(nWFTaskLogEntity);
                        }
                        else
                        {
                            db.Insert(item);
                        }
                    }
                }

                if (closeTaskList != null)
                {
                    foreach (var item in closeTaskList)
                    {
                        db.Update(item);
                    }
                }

                foreach (var task in taskList)
                {
                    task.F_ModifyDate = DateTime.Now;
                    db.Insert(task);
                    int num = 1;
                    if (task.nWFUserInfoList != null)
                    {
                        foreach (var taskUser in task.nWFUserInfoList)
                        {
                            NWFTaskRelationEntity nWFTaskRelationEntity = new NWFTaskRelationEntity();
                            nWFTaskRelationEntity.Create();
                            nWFTaskRelationEntity.F_TaskId = task.F_Id;
                            nWFTaskRelationEntity.F_UserId = taskUser.Id;
                            nWFTaskRelationEntity.F_Mark = taskUser.Mark;
                            nWFTaskRelationEntity.F_Result = 0;
                            nWFTaskRelationEntity.F_Sort = num;
                            db.Insert(nWFTaskRelationEntity);
                            num++;
                        }
                    }
                }
                foreach (var taskMsg in taskMsgList)
                {
                    db.Insert(taskMsg);
                }



                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 保存流程进程数据
        /// </summary>
        /// <param name="nWFProcessEntity">流程进程</param>
        public void Save(NWFProcessEntity nWFProcessEntity)
        {
            try
            {
                this.BaseRepository().Insert(nWFProcessEntity);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 保存流程进程数据
        /// </summary>
        /// <param name="nWFTaskLogEntity">任务日志数据</param>
        /// <param name="taskUserUpdateList">任务执行人需要更新状态数据</param>
        /// <param name="nWFTaskMsgEntity">任务消息</param>
        public void Save(NWFTaskLogEntity nWFTaskLogEntity, List<NWFTaskRelationEntity> taskUserUpdateList, NWFTaskMsgEntity nWFTaskMsgEntity)
        {
            var db = this.BaseRepository().BeginTrans();
            try
            {
                db.Insert(nWFTaskLogEntity);

                foreach (var item in taskUserUpdateList)
                {
                    db.Update(item);
                }
                db.Insert(nWFTaskMsgEntity);
                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }


        /// <summary>
        /// 保存流程进程数据
        /// </summary>
        /// <param name="nWFTaskLogEntity">任务日志数据</param>
        /// <param name="nWFTaskRelationEntity">任务执行人需要更新状态数据</param>
        /// <param name="taskEntity">任务</param>
        public void Save(NWFTaskLogEntity nWFTaskLogEntity, NWFTaskRelationEntity nWFTaskRelationEntity, NWFTaskEntity taskEntity)
        {
            var db = this.BaseRepository().BeginTrans();
            try
            {
                db.Insert(nWFTaskLogEntity);
                db.Update(nWFTaskRelationEntity);
                if (taskEntity != null)
                {
                    taskEntity.F_ModifyDate = DateTime.Now;
                    db.Update(taskEntity);
                }
                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 保存流程进程数据
        /// </summary>
        /// <param name="nWFTaskLogEntity">任务日志数据</param>
        /// <param name="taskList">需要更新的任务列表</param>
        /// <param name="taskMsgList">任务消息列表</param>
        public void Save(NWFTaskLogEntity nWFTaskLogEntity, List<NWFTaskEntity> taskList, List<NWFTaskMsgEntity> taskMsgList)
        {
            var db = this.BaseRepository().BeginTrans();
            try
            {
                db.Insert(nWFTaskLogEntity);
                foreach (var item in taskList)
                {
                    item.F_ModifyDate = DateTime.Now;
                    db.Update(item);
                }
                foreach (var item in taskMsgList)
                {
                    db.Insert(item);
                }
                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 保存流程进程数据
        /// </summary>
        /// <param name="nWFTaskLogEntity">任务日志数据</param>
        /// <param name="taskList">需要更新的任务列表</param>
        /// <param name="taskMsgList">任务消息列表</param>
        public void Save(NWFTaskLogEntity nWFTaskLogEntity, NWFTaskEntity task, List<NWFTaskMsgEntity> taskMsgList)
        {
            var db = this.BaseRepository().BeginTrans();
            try
            {
                db.Insert(nWFTaskLogEntity);
                task.F_ModifyDate = DateTime.Now;
                db.Update(task);
                foreach (var item in taskMsgList)
                {
                    db.Insert(item);
                }
                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 保存流程进程信息
        /// </summary>
        /// <param name="taskLogEntity">任务日志</param>
        /// <param name="taskRelationEntity">任务执行人状态更新</param>
        /// <param name="taskEntityUpdate">任务状态更新</param>
        /// <param name="processEntity">流程进程状态更新</param>
        /// <param name="taskList">新的任务列表</param>
        /// <param name="taskMsgList">新的任务消息列表</param>
        public void Save(NWFTaskLogEntity pTaskLogEntity, NWFTaskRelationEntity pTaskRelationEntity, NWFTaskEntity pTaskEntityUpdate, NWFProcessEntity pProcessEntity, List<NWFTaskEntity> pTaskList, List<NWFTaskMsgEntity> pTaskMsgList, NWFProcessEntity nWFProcessEntity, List<NWFTaskEntity> taskList, List<NWFTaskMsgEntity> taskMsgList, NWFTaskLogEntity taskLogEntity)
        {
            NWFProcessEntity nWFProcessEntityTmp = this.BaseRepository().FindEntity<NWFProcessEntity>(nWFProcessEntity.F_Id);
            IEnumerable<NWFTaskEntity> uTaskList = this.BaseRepository().FindList<NWFTaskEntity>(t => t.F_ProcessId == nWFProcessEntity.F_Id && t.F_NodeId == taskLogEntity.F_NodeId && t.F_IsFinished == 0);
            var db = this.BaseRepository().BeginTrans();
            try
            {
                if (nWFProcessEntityTmp == null)
                {
                    db.Insert(nWFProcessEntity);
                }
                else
                {
                    db.Update(nWFProcessEntity);
                }
                foreach (var task in taskList)
                {
                    task.F_ModifyDate = DateTime.Now;
                    db.Insert(task);
                    int num = 1;
                    if (task.nWFUserInfoList != null)
                    {
                        foreach (var taskUser in task.nWFUserInfoList)
                        {
                            NWFTaskRelationEntity nWFTaskRelationEntity = new NWFTaskRelationEntity();
                            nWFTaskRelationEntity.Create();
                            nWFTaskRelationEntity.F_TaskId = task.F_Id;
                            nWFTaskRelationEntity.F_UserId = taskUser.Id;
                            nWFTaskRelationEntity.F_Mark = taskUser.Mark;
                            nWFTaskRelationEntity.F_Result = 0;
                            nWFTaskRelationEntity.F_Sort = num;
                            db.Insert(nWFTaskRelationEntity);
                            num++;
                        }
                    }
                }
                foreach (var taskMsg in taskMsgList)
                {
                    db.Insert(taskMsg);
                }

                db.Insert(taskLogEntity);
                foreach (var item in uTaskList)
                {
                    item.F_IsFinished = 1;
                    db.Update(item);
                }


                // 父流程
                db.Insert(pTaskLogEntity);
                db.Update(pTaskRelationEntity);
                db.Update(pTaskEntityUpdate);
                if (pProcessEntity != null)
                {
                    db.Update(pProcessEntity);
                }

                foreach (var task in pTaskList)
                {
                    task.F_ModifyDate = DateTime.Now;
                    db.Insert(task);
                    int num = 1;
                    if (task.nWFUserInfoList != null)
                    {
                        foreach (var taskUser in task.nWFUserInfoList)
                        {
                            NWFTaskRelationEntity nWFTaskRelationEntity = new NWFTaskRelationEntity();
                            nWFTaskRelationEntity.Create();
                            nWFTaskRelationEntity.F_TaskId = task.F_Id;
                            nWFTaskRelationEntity.F_UserId = taskUser.Id;
                            nWFTaskRelationEntity.F_Mark = taskUser.Mark;
                            nWFTaskRelationEntity.F_Result = 0;
                            nWFTaskRelationEntity.F_Sort = num;
                            db.Insert(nWFTaskRelationEntity);
                            num++;
                        }
                    }
                }
                foreach (var taskMsg in pTaskMsgList)
                {
                    db.Insert(taskMsg);
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// （流程撤销）
        /// </summary>
        /// <param name="processId">流程进程实例</param>
        /// <param name="taskList">流程任务列表</param>
        /// <param name="EnabledMark">2草稿3作废</param>
        public void Save(string processId, IEnumerable<NWFTaskEntity> taskList, int EnabledMark, NWFTaskLogEntity nWFTaskLogEntity = null)
        {
            var db = this.BaseRepository().BeginTrans();
            try
            {
                NWFProcessEntity nWFProcessEntity = new NWFProcessEntity();
                nWFProcessEntity.F_Id = processId;
                nWFProcessEntity.F_EnabledMark = EnabledMark;
                db.Update(nWFProcessEntity);
                if (EnabledMark == 2)
                {
                    db.Delete<NWFTaskLogEntity>(t => t.F_ProcessId == processId);
                }
                foreach (var task in taskList)
                {
                    db.Delete(task);
                    string taskId = task.F_Id;
                    db.Delete<NWFTaskMsgEntity>(t => t.F_TaskId == taskId);
                    db.Delete<NWFTaskRelationEntity>(t => t.F_TaskId == taskId);
                }
                if (nWFTaskLogEntity != null)
                {
                    db.Insert(nWFTaskLogEntity);
                }
                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 删除流程进程实体
        /// </summary>
        /// <param name="processId">流程进程主键</param>
        public void DeleteEntity(string processId)
        {
            try
            {
                this.BaseRepository().Delete<NWFProcessEntity>(t => t.F_Id == processId);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="processId"></param>
        /// <param name="EnabledMark"></param>
        public void UpdateEnabledMark(string processId, string EnabledMark)
        {
            try
            {
                var entity = this.BaseRepository().FindEntity<NWFProcessEntity>(t => t.F_Id == processId);
                entity.F_EnabledMark = Convert.ToInt32(EnabledMark);
                this.BaseRepository().Update(entity);
            }
            catch (Exception ex)
            {
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 删除流程进程所有信息（流程撤销）
        /// </summary>
        /// <param name="processId">流程进程实例</param>
        /// <param name="taskList">流程任务列表</param>
        public void Delete(string processId, IEnumerable<NWFTaskEntity> taskList)
        {
            var db = this.BaseRepository().BeginTrans();
            try
            {
                db.Delete<NWFProcessEntity>(t => t.F_Id == processId);
                db.Delete<NWFTaskLogEntity>(t => t.F_ProcessId == processId);
                foreach (var task in taskList)
                {
                    db.Delete(task);
                    string taskId = task.F_Id;
                    db.Delete<NWFTaskMsgEntity>(t => t.F_TaskId == taskId);
                    db.Delete<NWFTaskRelationEntity>(t => t.F_TaskId == taskId);
                }

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }


        /// <summary>
        /// 撤销审核
        /// </summary>
        /// <param name="taskList">需要撤回的任务节点</param>
        /// <param name="taskUser">当前处理人</param>
        /// <param name="taskEntity">当前任务</param>
        /// <param name="taskLogEntity">日志信息</param>
        /// <param name="taskUserNew">当前任务节点的处理人（串行多人审核）</param>
        public void RevokeAudit(List<string> taskList, NWFTaskRelationEntity taskUser, NWFTaskEntity taskEntity, NWFTaskLogEntity taskLogEntity, NWFTaskRelationEntity taskUserNew = null)
        {
            var db = this.BaseRepository().BeginTrans();
            try
            {
                if (taskList != null)
                {
                    foreach (var taskId in taskList)
                    {
                        db.Delete<NWFTaskEntity>(t => t.F_Id == taskId);
                        db.Delete<NWFTaskRelationEntity>(t => t.F_TaskId == taskId);
                        db.Delete<NWFTaskMsgEntity>(t => t.F_TaskId == taskId);
                    }
                }

                if (taskEntity != null)
                {
                    db.Update(taskEntity);
                }

                taskUser.F_Mark = 0;
                taskUser.F_Result = 0;
                db.Update(taskUser);

                db.Insert(taskLogEntity);

                if (taskUserNew != null)
                {
                    taskUserNew.F_Mark = 1;
                    taskUserNew.F_Result = 0;
                    db.Update(taskUserNew);
                }


                // 更新下流程实例（处理重新发起状态）
                NWFProcessEntity nWFProcessEntity = new NWFProcessEntity();
                nWFProcessEntity.F_Id = taskLogEntity.F_ProcessId;
                nWFProcessEntity.F_IsAgain = 0;
                db.Update(nWFProcessEntity);

                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }

        /// <summary>
        /// 保存任务
        /// </summary>
        /// <param name="taskList">任务列表</param>
        public void SaveTask(List<NWFTaskEntity> taskList)
        {
            var db = this.BaseRepository().BeginTrans();

            try
            {
                foreach (var task in taskList)
                {
                    task.F_ModifyDate = DateTime.Now;
                    db.Insert(task);
                    int num = 1;
                    if (task.nWFUserInfoList != null)
                    {
                        foreach (var taskUser in task.nWFUserInfoList)
                        {
                            NWFTaskRelationEntity nWFTaskRelationEntity = new NWFTaskRelationEntity();
                            nWFTaskRelationEntity.Create();
                            nWFTaskRelationEntity.F_TaskId = task.F_Id;
                            nWFTaskRelationEntity.F_UserId = taskUser.Id;
                            nWFTaskRelationEntity.F_Mark = taskUser.Mark;
                            nWFTaskRelationEntity.F_Result = 0;
                            nWFTaskRelationEntity.F_Sort = num;
                            db.Insert(nWFTaskRelationEntity);
                            num++;
                        }
                    }
                }

                db.Commit();
            }
            catch (Exception)
            {
                db.Rollback();
                throw;
            }


        }

        /// <summary>
        /// 流程监控统计耗时最长信息
        /// </summary>
        public void StatisticsData()
        {
            var db = this.BaseRepository();
            try
            {
                db.BeginTrans();
                var processList = db.FindList<NWFProcessEntity>(t => t.F_EnabledMark != 2 && t.F_IsChild == 0).ToList();

                //删除今天统计的数据，每天只记录一份数据
                db.ExecuteBySql("delete from LR_NWF_ProcessStatistics where DateDiff(dd,F_CreateDate,getdate())=0");

                var NTRList = db.FindList<NWFTaskRelationEntity>($"SELECT * FROM LR_NWF_TaskRelation").ToList();
                var userList = db.FindList<UserEntity>(x => x.F_DeleteMark == 0).ToList();
                var deptList = db.FindList<DepartmentEntity>().ToList();
                //Action<IRepository, NWFProcessEntity, List<NWFTaskRelationEntity>, List<UserEntity>, List<DepartmentEntity>> action = new Action<IRepository, NWFProcessEntity, List<NWFTaskRelationEntity>, List<UserEntity>, List<DepartmentEntity>>(AddProcessStatistics);

                //RunTask<NWFProcessEntity>(processList, action);

                ConcurrentQueue<NWFProcessEntity> queue = new ConcurrentQueue<NWFProcessEntity>(processList);
                int threadCount = 10; //开启10个线程
                for (int i = 0; i < threadCount; i++)
                {
                    string fileName = $"task{i}.txt";
                    //开启新线程
                    Task.Factory.StartNew(() =>
                    {
                        var sb = new StringBuilder();
                        int j = 0;
                        //数据循环出队
                        while (queue.TryDequeue(out NWFProcessEntity model))
                        {
                            //处理数据
                            if (model != null)
                                AddProcessStatistics(db, model, NTRList, userList, deptList);

                            if (j % 100 == 0 || (queue.Count.Equals(0) && j < 100))
                            {
                                Thread.Sleep(100);
                            }
                            j++;
                        }

                    });
                }
                db.Commit();
            }
            catch (Exception ex)
            {
                db.Rollback();
                if (ex is ExceptionEx)
                {
                    throw;
                }
                else
                {
                    throw ExceptionEx.ThrowServiceException(ex);
                }
            }
        }
        /// <summary>
        /// 流程监控统计表添加数据
        /// </summary>
        /// <param name="db"></param>
        /// <param name="model"></param>
        /// <param name="NTRList"></param>
        /// <param name="userList"></param>
        /// <param name="deptList"></param>
        private void AddProcessStatistics(IRepository db, NWFProcessEntity model, List<NWFTaskRelationEntity> NTRList, List<UserEntity> userList, List<DepartmentEntity> deptList)
        {
            var userNames = "";
            var tasklist = db.FindList<NWFTaskEntity>(t => t.F_ProcessId == model.F_Id && t.F_IsFinished == 0).FirstOrDefault();
            if (tasklist != null && !string.IsNullOrEmpty(tasklist.F_Id))
            {
                List<string> usernamelist = new List<string>();
                List<string> nextlist = NTRList.Where(x => x.F_TaskId == tasklist.F_Id).Select(m => m.F_UserId).ToList();

                foreach (var uid in nextlist)
                {
                    var userentity = userList.Find(x => x.F_UserId == uid);
                    string deptname = deptList.Find(x => x.F_DepartmentId == userentity?.F_DepartmentId)?.F_FullName;
                    usernamelist.Add("[" + deptname + "]" + userentity?.F_RealName);
                }
                userNames = string.Join(",", usernamelist);
            }

            var addSql = $@"INSERT INTO [dbo].[LR_NWF_ProcessStatistics]
           ([Id]
           ,[F_ProcessId]
           ,[F_SchemeId]
           ,[F_SchemeCode]
           ,[F_SchemeName]
           ,[F_Title]
           ,[F_Level]
           ,[F_EnabledMark]
           ,[F_IsAgain]
           ,[F_IsFinished]
           ,[F_IsChild]
           ,[F_IsAsyn]
           ,[F_ParentNodeId]
           ,[F_ParentTaskId]
           ,[F_ParentProcessId]
           ,[F_IsStart]
           ,[F_CurrentHandler]
           ,[F_LongestTimeProcessor]
           ,[F_LongestTime]
           ,[F_CreateDate]
           ,[F_CreateUserId])
     VALUES
           (newid()
           ,'{model.F_Id}'
           ,'{model.F_SchemeId}'
           ,'{model.F_SchemeCode}'
           ,'{model.F_SchemeName}'
           ,'{model.F_Title}'
           ,'{model.F_Level}'
           ,'{model.F_EnabledMark}'
           ,'{model.F_IsAgain}'
           ,'{model.F_IsFinished}'
           ,'{model.F_IsChild}'
           ,'{model.F_IsAsyn}'
           ,'{model.F_ParentNodeId}'
           ,'{model.F_ParentTaskId}'
           ,'{model.F_ParentProcessId}'
           ,'{model.F_IsStart}'
           ,'{userNames}'
           ,''--最长耗时处理人
           ,null--最长耗时处理时间
           ,GETDATE()
           ,'{LoginUserInfo.Get().userId}')";

            db.ExecuteBySql(addSql);
        }


        /// <summary>
        /// 多线程处理数据（无返回值）
        /// </summary>
        /// <typeparam name="T">数据类型</typeparam>
        /// <param name="list">待处理数据</param>
        /// <param name="action">数据处理方法（有参数无返回值）</param>
        /// <param name="count">处理线程数量</param>
        /// <param name="waitFlag">是否等待执行结束</param>
        public static void RunTask<T>(List<T> list, Action<T, T, T, T, T> action, IRepository db, int threadCount = 5, bool waitFlag = true)
        {
            ConcurrentQueue<T> queue = new ConcurrentQueue<T>(list);
            Task[] tasks = new Task[threadCount];
            for (int i = 0; i < threadCount; i++)
            {
                tasks[i] = Task.Factory.StartNew(() =>
                {
                    while (queue.TryDequeue(out T t))
                    {
                        //action(db,t);
                    }
                });
            }
            if (waitFlag)
            {
                Task.WaitAll(tasks);
            }
        }
        #endregion
    }
}