ZLPMS/PMS.DBService/WorkFlow/WorkFlowService.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using PMS.EntityModels.WorkFlow;
using QWPlatform.IService;
using PMS.BusinessModels.Problem;
using System.Data;
using PMS.BusinessModels.MobileProblem;
using QWPlatform.SystemLibrary.LogManager;
using QWPlatform.SystemLibrary;
using PMS.BusinessModels.Account;
using PMS.Plugins.Common;

namespace PMS.DBService.WorkFlow
{
    /// <summary> 
    /// 创 建 人：王海洋
    /// 创建日期：2019-01-25
    /// 功能描述：问题工作流服务
    /// </summary> 
    public class WorkFlowService : DataServiceBase
    {
        protected override void DBFctory(string conName)
        {
            base.DBFctory(conName);
        }

        /// <summary>
        /// 列表查询(根据目录ID查询)
        /// </summary>
        /// <param name="CategoryID">目录ID</param>
        /// <returns>返回该目录下有效的工作流列表</returns>
        public List<WorkFlowModel> SelectList(int categoryID)
        {
            var model = new WorkFlowModel()
            {
                CategoryID = categoryID,
                Active = 1
            };

            model.SetDataFactory(this.DataFactoryObject);
            return model.SelectList<WorkFlowModel>();
        }

        /// <summary>
        /// 根据流程ID获取模型
        /// </summary>
        /// <param name="id">ID</param>
        /// <returns></returns>
        public WorkFlowModel GetModelById(int workflowid)
        {
            var model = new WorkFlowModel()
            {
                ID = workflowid
            };

            model.SetDataFactory(this.DataFactoryObject);
            var r = model.Select();
            if (r)
            {   //返回查询结果的model
                return model;
            }

            return null;
        }



        /// <summary>
        /// 根据工作流返回上一工作流的ID
        /// </summary>
        /// <param name="id">ID</param>
        /// <returns></returns>
        public int? GetPreviousID(int workflowid)
        {
            var model = GetModelById(workflowid);
            if (model != null)
            {//获取到model
                return model.PreviousID;
            }

            return null;
        }


        #region 登记新问题

        /// <summary>
        /// 根据工作流ID获取下一工作流的ID
        /// </summary>
        /// <param name="categoryID">分类目录ID</param>
        /// <param name="personProperty">人员性质，1:本部人员,2:渠道人员,3:	操作员,4:医院管理员,5:卫计委管理员</param>
        /// <param name="problemProperty">问题性质,1:Bug,2:咨询,3:需求,4:优化</param>
        /// <returns>返回处理流程的ID</returns>
        public int? GetNewRequirementWorkFlowID(int categoryID, int personProperty, int problemProperty)
        {
            var sql = @"select t.ID 
                                from 问题工作流程 t , 问题流程环节 b
                            where t.环节id = b.Id
                                and t.目录ID =:categoryID
                                and t.环节ID =5 ";//环节ID：5 为研发处理

            var result = this.SqlBuilder
                 .SqlText(sql)
                 .Parameters("categoryID", categoryID)
                 .Select<int>();
            if (result == 0)
            {
                Logger.Instance.Error("调用GetNewRequirementWorkFlowID方法,获取进入流程ID为0！");
            }
            return result;
        }

        /// <summary>
        /// 登录一个新的Bug问题,返回新的流程ID
        /// </summary>
        /// <param name="categoryID">目录分类ID</param>
        /// <param name="personProperty">人员性质</param>
        /// <returns>返回登记bug跳到下一个流程ID</returns>
        public int? GetNewBugProblemWorkFlowID(int categoryID, int personProperty)
        {
            int? workflowid;
            ///如果登记的人员是客户
            if (personProperty == 3)
            {
                //获取目标流程ID
                var sql = @"select 目标ID from 问题工作流程 where 目录ID=:categoryID and 环节ID=0 ";
                workflowid = this.SqlBuilder
                                 .SqlText(sql)
                                 .Parameters("categoryID", categoryID)
                                 .Select<int>();
            }
            ///如果是其他管理员
            else
            {
                //获取目标流程ID
                var sql = @"select t.id 
                                from 问题工作流程 t , 问题流程环节 b
                            where  t.环节id >= b.Id
                                and t.目录ID=:categoryID
                                and b.人员性质=:personProperty
                                and rownum=1 order by t.序号 asc ";
                workflowid = this.SqlBuilder
                                 .SqlText(sql)
                                 .Parameters("categoryID", categoryID)
                                 .Parameters("personProperty", personProperty)
                                 .Select<int>();
            }
            if (workflowid == 0)
            {
                Logger.Instance.Error("调用GetNewBugProblemWorkFlowID方法,获取进入流程ID为0！");
            }
            return workflowid;
        }

        #endregion

        #region 提交获取下个流程ID
        /// <summary>
        /// 获取正常流程的下一个ID
        /// </summary>
        /// <param name="personProperty">人员性质</param>
        /// <param name="problemId">问题ID</param>
        /// <returns>返回下个流程ID，如果人员性质不匹配，则返回为0</returns>
        public int GetSubmitNextWorkFlowID(int personProperty, string problemId)
        {
            var sql = @"select w.目标id  from 问题记录 t,问题工作流程 w, 问题流程环节 b
                            where t.流程id = w.Id
                                and w.环节id =b.Id
                                and t.id = :ID
                                and b.人员性质=:人员性质";

            var workflowid = this.SqlBuilder
                        .SqlText(sql)
                        .Parameters("ID", problemId)
                        .Parameters("人员性质", personProperty)
                        .Select<int>();
            if (workflowid == 0)
            {
                Logger.Instance.Error("调用GetSubmitNextWorkFlowID方法,获取进入流程ID为0！");
            }
            return workflowid;
        }

        /// <summary>
        /// 跳转流程处理方式，即通过当前问题没有找到匹配的下一个流程ID，即根据人员性质与目录ID，获取当前人员处理的下一个流程ID
        /// 直接根据当前人员的性质进行判断下一步流转到哪里，例如，当前是卫计委管理员，则直接流程到项目处理，如果当前是项目处理
        /// 向上提交直接流转到技术支持，如果是项目支持人员，直接流转到研发，跟问题当前处于哪个环节无关。
        /// </summary>
        /// <param name="categoryId">目录ID</param>
        /// <param name="personProperty">人员性质</param>
        /// <returns></returns>
        public int GetSubmitSkipNextWorkFlowID(int personProperty, string problemId)
        {
            ///获取目录Id
            var categoryId = this.SelectBuilder.From("问题记录 a,问题工作流程 b").Columns("b.目录ID").Where("a.流程ID=b.ID").Where("a.ID", problemId).Select<int>();
            var sql = @"select t.目标id from 问题工作流程 t,问题流程环节 b
                            where t.环节id >= b.Id
                            and  t.目录ID = :目录ID
                            and b.人员性质= :人员性质 order by t.序号 asc ";
            var workflowid = this.SqlBuilder
                        .SqlText(sql)
                        .Parameters("目录ID", categoryId)
                        .Parameters("人员性质", personProperty)
                        .Select<int>();
            if (workflowid == 0)
            {
                Logger.Instance.Error("调用GetSubmitSkipNextWorkFlowID方法,获取进入流程ID为0！");
            }
            return workflowid;
        }
        #endregion

        #region 回退问题

        /// <summary>
        /// 获取回退的流程ID
        /// </summary>
        /// <param name="categoryId"></param>
        /// <param name="problemId"></param>
        /// <returns></returns>
        public int GetBackWorkFlowID(string problemId)
        {
            var sql = @"select t.来源流程ID from 问题记录过程 t, 问题记录 r
                        where t.问题id = r.Id
                              and r.id = :问题ID
                              and t.当前流程id = r.流程id
                              and t.当前流程id > t.来源流程ID
                              order by t.记录时间 desc ";

            var workflowid = this.SqlBuilder
                        .SqlText(sql)
                        .Parameters("问题ID", problemId)
                        .Select<int>();
            if (workflowid == 0)
            {
                Logger.Instance.Error("调用GetBackWorkFlowID方法,获取进入流程ID为0！");
            }
            return workflowid;
        }
        #endregion

        #region 问题操作相关
        /// <summary>
        /// 获取非提交回退类处理操作的一进入流程Id
        /// </summary>
        /// <param name="problemId"></param>
        /// <param name="personProperty"></param>
        /// <returns></returns>
        public int? GetDealWorkId(string problemId, int personProperty, string JobCode)
        {
            ///获取目录Id
            var categoryId = this.SelectBuilder.Columns("b.目录ID").From("问题记录 a,问题工作流程 b").Where("a.流程ID=b.ID").Where("a.ID", problemId).Select<int>();

            var sql = @"select t.id 
                                from 问题工作流程 t , 问题流程环节 b 
                            where  t.环节id >= b.Id
                                and t.目录ID=:categoryID
                                and b.人员性质=:personProperty
                                ";
            var SqlBuilder = this.SqlBuilder;
            SqlBuilder.Parameters("categoryID", categoryId)
                      .Parameters("personProperty", personProperty);
            if (personProperty == 1)
            {
                sql += @" and Exists
                           (select column_value from table(Select f_Split_String(x.职务代码1, ',') from 问题流程环节 x
                            where id = b.Id)
                            where Column_Value =:Job) ";
                SqlBuilder.Parameters("Job", Convert.ToInt32(JobCode));
            }
            sql += " order by t.序号 asc ";
            var workflowid = SqlBuilder
                              .SqlText(sql)
                              .Select<int>();
            if (workflowid == 0)
            {
                Logger.Instance.Warn("调用GetDealWorkId方法,获取进入流程ID为0！");
            }
            return workflowid;
        }
        /// <summary>
        /// 问题受理
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public int ProblemAccept(ProblemDealModel Model)
        {
            //判断进入流程ID是否为0
            if (Model.NextWorkId == 0)
            {
                Logger.Instance.Error("调用ProblemAccept方法传入的进入流程ID为0，请检查获取进入流程ID方法");
                return 0;
            }
            return this.ProcedureBuilder
                             .Procedure("B_问题处理.P_问题受理")
                             .Paramter("问题ID_In", Model.ProblemId)
                             .Paramter("进入流程ID_In", Model.NextWorkId)
                             .Paramter("操作人_In", Model.DealPeronName)
                             .Paramter("操作人ID_In", Model.DealPeronId)
                             .Paramter("操作时间_In", this.DataBaseBuilder.GetDateTime)
                             .Paramter("耗时_In", PassTime(Model.ProblemId))
                             .Execute();
        }
        /// <summary>
        /// 问题回退
        /// </summary>
        /// <returns></returns>
        public int ProblemRollBack(ProblemDealModel Model, out string ProcessId)
        {
            //判断进入流程ID是否为0
            if (Model.NextWorkId == 0)
            {
                Logger.Instance.Error("调用ProblemRollBack方法传入的进入流程ID为0，请检查获取进入流程ID方法");
                ProcessId = "";
                return 0;
            }
            var Pro = this.ProcedureBuilder
                             .Procedure("B_问题处理.P_问题回退")
                             .Paramter("问题ID_In", Model.ProblemId)
                             .Paramter("进入流程ID_In", Model.NextWorkId)
                             .Paramter("操作描述_In", Model.Describe)
                             .Paramter("操作人ID_In", Model.DealPeronId)
                             .Paramter("操作时间_In", this.DataBaseBuilder.GetDateTime)
                             .Paramter("耗时_In", PassTime(Model.ProblemId))
                             .ParamterOut("过程ID_Out", DbType.String, 36);
            var result = Pro.Execute();
            ProcessId = Pro.ParameterValue<string>("过程ID_Out");
            try
            {
                if (!string.IsNullOrEmpty(Model.ProblemTypeID))
                {
                    UpdateBuilder.Update("问题记录").Where("ID", Model.ProblemId).Column("技术支持分类ID", Model.ProblemTypeID).Execute();
                }
            }
            catch (Exception ex)
            {

                Logger.Instance.Error("[加分类ID是为了服务部方便统计咨询回退问题]问题回退分类出现异常:" + ex);
            }
          
            return result;
        }
        /// <summary>
        /// 问题终止
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public int ProblemBreak(ProblemDealModel Model, out string ProcessId)
        {
            var Pro = this.ProcedureBuilder
                          .Procedure("B_问题处理.P_问题终止")
                          .Paramter("问题ID_In", Model.ProblemId)
                          .Paramter("操作描述_In", Model.Describe)
                          .Paramter("操作人ID_In", Model.DealPeronId)
                          .Paramter("操作时间_In", this.DataBaseBuilder.GetDateTime)
                          .Paramter("耗时_In", PassTime(Model.ProblemId))
                          .ParamterOut("过程ID_Out", DbType.String, 36);
            var result = Pro.Execute();
            ProcessId = Pro.ParameterValue<string>("过程ID_Out");

            if (!string.IsNullOrEmpty(Model.ProblemTypeID))
            {
                if (SqlBuilder.SqlText("select  性质 from 人员信息 where id=:ID").Parameters("ID", Model.DealPeronId).Select().Rows[0]["性质"].ToInt32() == 1)
                {
                    UpdateBuilder.Update("问题记录").Where("ID", Model.ProblemId).Column("技术支持分类ID", Model.ProblemTypeID).Execute();
                }
                else
                {
                    UpdateBuilder.Update("问题记录").Where("ID", Model.ProblemId).Column("分类ID", Model.ProblemTypeID).Execute();
                }
            }

            return result;
        }
        /// <summary>
        /// 问题指派
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public int ProblemAssgin(ProblemDealModel Model, out string ProcessId)
        {
            //判断进入流程ID是否为0
            if (Model.NextWorkId == 0)
            {
                Logger.Instance.Error("调用ProblemAssgin方法传入的进入流程ID为0，请检查获取进入流程ID方法");
                ProcessId = "";
                return 0;
            }
            try
            {
                var Pro = this.ProcedureBuilder
                                          .Procedure("B_问题处理.P_问题指派")
                                          .Paramter("问题ID_In", Model.ProblemId)
                                          .Paramter("进入流程ID_In", Model.NextWorkId)
                                          .Paramter("操作描述_In", Model.Describe)
                                          .Paramter("操作人ID_In", Model.DealPeronId)
                                          .Paramter("操作时间_In", this.DataBaseBuilder.GetDateTime)
                                          .Paramter("指派人_In", Model.AssignPersonName)
                                          .Paramter("指派人ID_In", Model.AssignPersonId)
                                          .Paramter("耗时_In", PassTime(Model.ProblemId))
                                          .ParamterOut("过程ID_Out", DbType.String, 36);
                var result = Pro.Execute();
                ProcessId = Pro.ParameterValue<string>("过程ID_Out");
                return result;
            }
            catch (Exception ex)
            {
                Logger.Instance.Error("调用问题指派存储过程失败", ex);
                ProcessId = "";
                return 0;
            }

        }
        /// <summary>
        /// 问题处理
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public int ProblemDeal(ProblemDealModel Model, out string ProcessId)
        {
            //判断进入流程ID是否为0
            if (Model.NextWorkId == 0)
            {
                Logger.Instance.Error("调用ProblemDeal方法传入的进入流程ID为0，请检查获取进入流程ID方法");
                ProcessId = "";
                return 0;
            }
            var Pro = this.ProcedureBuilder
                           .Procedure("B_问题处理.P_问题处理")
                           .Paramter("问题ID_In", Model.ProblemId)
                           .Paramter("进入流程ID_In", Model.NextWorkId)
                           .Paramter("操作描述_In", Model.Describe)
                           .Paramter("操作人_In", Model.DealPeronName)
                           .Paramter("操作人ID_In", Model.DealPeronId)
                           .Paramter("操作时间_In", this.DataBaseBuilder.GetDateTime)
                           .Paramter("耗时_In", PassTime(Model.ProblemId))
                           .ParamterOut("过程ID_Out", DbType.String, 36);
            var result = Pro.Execute();
            ProcessId = Pro.ParameterValue<string>("过程ID_Out");
            return result;
        }
        /// <summary>
        /// 问题完成
        /// </summary>
        /// <param name="Model"></param>
        /// <returns></returns>
        public int ProblemSolution(ProblemDealModel model, out string ProcessId, UserInfo user)
        {
            //判断进入流程ID是否为0
            if (model.NextWorkId == 0)
            {
                Logger.Instance.Error("调用ProblemSolution方法传入的进入流程ID为0，请检查获取进入流程ID方法");
                ProcessId = "";
                return 0;
            }
            var Pro = this.ProcedureBuilder.Procedure("B_完成处理提交.P_问题完成")
                     .Paramter("问题ID_In", model.ProblemId)
                     .Paramter("操作人_In", model.DealPeronName)
                     .Paramter("操作人ID_In", model.DealPeronId)
                     .Paramter("进入流程ID_In", model.NextWorkId)
                     .Paramter("耗时_In", PassTime(model.ProblemId))
                     .Paramter("解决方案_In", model.Describe)
                     .Paramter("解决版本_In", model.Version)
                     .Paramter("描述_In", model.Describe)
                     .Paramter("操作时间_In", this.DataBaseBuilder.GetDateTime)
                     .ParamterOut("过程ID_Out", DbType.String, 36);
            var result = Pro.Execute();
            var CSCLR = "";
            if (!model.TestPeronId.IsNullOrEmpty())//获取测试人员
            {
                CSCLR = SelectBuilder.From("人员信息").Columns("姓名").Where("ID", model.TestPeronId).Select().Rows[0]["姓名"].ToString();

            }
            //更新测试处理人有
            this.UpdateBuilder.Update("问题记录").Column("测试处理人ID", model.TestPeronId).Column("测试处理人", CSCLR).Column("解决版本ID", model.VersionID).Where("ID", model.ProblemId).Execute();
            //若处理人未研发人员则变更研发处理人为当前登录人
            foreach (var item in user.Roles)
            {
                if (item.ToInt32() == 7 || item.ToInt32() == 9 || item.ToInt32() == 10 || item.ToInt32() == 317 )
                {
                    UpdateBuilder.Update("问题记录").Column("研发处理人ID", model.DealPeronId).Column("研发处理人", model.DealPeronName).Where("id",model.ProblemId).Execute();
                    break;
                }
            }


            ProcessId = Pro.ParameterValue<string>("过程ID_Out");
            //如果选择了问题分类，则更新分类
            if (!string.IsNullOrEmpty(model.ProblemTypeID))
            {
                if (SqlBuilder.SqlText("select  性质 from 人员信息 where id=:ID").Parameters("ID", model.DealPeronId).Select().Rows[0]["性质"].ToInt32() == 1)
                {
                    UpdateBuilder.Update("问题记录").Where("ID", model.ProblemId).Column("技术支持分类ID", model.ProblemTypeID).Execute();
                }
                else
                {
                    UpdateBuilder.Update("问题记录").Where("ID", model.ProblemId).Column("分类ID", model.ProblemTypeID).Execute();
                }
            }
            var dt = this.SelectBuilder.Columns("a.产品ID").From("问题记录 a").Where("a.ID", model.ProblemId).Select();
           var ProductId = "";
            if (dt.Rows.Count>0)
            {
                ProductId = dt.Rows[0].GetValueByName<string>("产品ID");
            }
            //加入到版本计划中
            this.DeleteBulider.Delete("产品问题版本").Where("问题ID", model.ProblemId).Execute();
            this.InsertBuilder.Insert("产品问题版本").Column("ID", Guid.NewGuid().ToString())
                    .Column("问题ID", model.ProblemId).Column("版本ID", model.VersionID).Column("产品ID", ProductId).Execute();

            return result;

        }
        /// <summary>
        /// 撤销完成/终止
        /// </summary>
        /// <param name="ProblemId"></param>
        /// <param name="PersonId"></param>
        /// <returns></returns>
        public bool UndoProblem(string ProblemId, string PersonId)
        {
            this.DeleteBulider.Delete("产品问题版本").Where("问题ID", ProblemId).Execute();
            using (var tran = this.DBTransaction.BeginTrans())
            {
                try
                {
                    var t = this.UpdateBuilder
                           .Column("是否终止", 0)
                           .Column("是否解决", 0)
                           .Column("终止说明", DBNull.Value)
                           .Column("终止日期", DBNull.Value)
                           .Column("解决方案", DBNull.Value)
                           .Column("是否验证", 0)
                           .Column("验证人ID", DBNull.Value)
                           .Update("问题记录")
                           .Where("ID", ProblemId)
                           .Execute(tran);
                    var dt = this.SqlBuilder.SqlText("Select * from (Select 当前流程ID,记录时间 from 问题记录过程 where 问题ID=:id order by 记录时间 desc) where rownum=1")
                                          .Parameters("id", ProblemId).Select();
                    var ProcessId = dt.Rows[0].GetValueByName<int>("当前流程ID");
                    //计算耗时
                    var ProcessTime = dt.Rows[0].GetValueByName<DateTime>("记录时间");
                    DateTime CurrentTime = this.DataBaseBuilder.GetDateTime;
                    TimeSpan time = CurrentTime - ProcessTime;
                    var PassTime = time.TotalMinutes / 60;
                    //添加过程
                    var inserProcess = this.InsertBuilder
                                         .Column("ID", Guid.NewGuid().ToString())
                                         .Column("问题ID", ProblemId)
                                         .Column("记录人ID", PersonId)
                                         .Column("记录时间", CurrentTime)
                                         .Column("当前流程ID", ProcessId)
                                         .Column("状态", 10)
                                         .Column("来源流程ID", ProcessId)
                                         .Column("耗时", PassTime)
                                         .Insert("问题记录过程")
                                         .Execute(tran);
                    tran.CommitTrans();
                    return (t > 0 && inserProcess > 0);
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    Logger.Instance.Error("撤销完成/终止失败", ex);
                    return false;
                }
            }
           
        }
        /// <summary>
        /// 问题提交
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool ProblemSubmit(ProblemDealModel model)
        {
            //判断进入流程ID是否为0
            if (model.NextWorkId == 0)
            {
                Logger.Instance.Error("调用ProblemSubmit方法传入的进入流程ID为0，请检查获取进入流程ID方法");
                return false;
            }
            using (var tran = this.DBTransaction.BeginTrans())
            {
                try
                {


                    var t = this.ProcedureBuilder.Procedure("B_完成处理提交.P_问题提交")
                           .Paramter("问题ID_In", model.ProblemId)
                           .Paramter("操作人ID_In", model.DealPeronId)
                           .Paramter("耗时_In", PassTime(model.ProblemId))
                           .Paramter("进入流程ID", model.NextWorkId)
                           .Paramter("操作描述_In", !string.IsNullOrEmpty(model.Describe) ? model.Describe : "向上提交")
                           .Paramter("操作时间_In", this.DataBaseBuilder.GetDateTime)
                           .Paramter("被指派人ID", model.SubID)
                           .Paramter("被指派人", model.SubName)
                           .Execute(tran);
                    var s = 1;
                    ///如果有向上提交人
                    if (!string.IsNullOrEmpty(model.SubID) && !string.IsNullOrEmpty(model.SubName))
                    {
                        s = this.UpdateBuilder.Column("是否受理", 1)
                                            .Column("受理人", model.SubName)
                                            .Column("受理人ID", model.SubID)
                                            .Column("指派人", model.SubName)
                                            .Column("指派人ID", model.SubID)
                                            .Column("指派时间", this.DataBaseBuilder.GetDateTime)
                                            .Column("受理时间", this.DataBaseBuilder.GetDateTime)
                                            .Where("ID", model.ProblemId)
                                            .Update("问题记录")
                                            .Execute(tran);
                    }
                    tran.CommitTrans();
                    //如果选择了问题分类，则更新分类
                    if (!string.IsNullOrEmpty(model.ProblemTypeID))
                    {
                        if (SqlBuilder.SqlText("select  性质 from 人员信息 where id=:ID").Parameters("ID", model.DealPeronId).Select().Rows[0]["性质"].ToInt32() == 1)
                        {
                            UpdateBuilder.Update("问题记录").Where("ID", model.ProblemId).Column("技术支持分类ID", model.ProblemTypeID).Execute();
                        }
                        else
                        {
                            UpdateBuilder.Update("问题记录").Where("ID", model.ProblemId).Column("分类ID", model.ProblemTypeID).Execute();
                        }
                    }
                    return (t == -1 && s > 0);

                }
                catch (Exception ex)
                {
                    Logger.Instance.Error("调用问题提交ProblemSubmit发生错误", ex);
                    tran.Rollback();
                    return false;
                }
            }


        }
        /// <summary>
        /// 计算耗时
        /// </summary>
        /// <param name="ProblemID"></param>
        /// <returns></returns>
        public Double PassTime(string ProblemID)
        {
            DateTime datime = SelectBuilder.From("问题记录过程").Columns("记录时间").Where("问题ID", ProblemID).OrderBy("记录时间 Desc").Select<DateTime>();
            DateTime CurrentTime = this.DataBaseBuilder.GetDateTime;
            TimeSpan time = CurrentTime - datime;
            return time.TotalMinutes / 60;
        }
        public int SaveProcessFile(ProcessFileModel Model)
        {
            try
            {
                ///获取问题ID
                var ProblemId = this.SelectBuilder.From("问题记录过程").Where("ID", Model.ProcessId).Columns("问题ID").Select<string>();
                return this.InsertBuilder.Insert("产品问题附件").Column("ID", Guid.NewGuid().ToString())
                                                                .Column("问题ID", ProblemId)
                                                                .Column("过程ID", Model.ProcessId)
                                                                .Column("类型", Model.Type)
                                                                .Column("附件ID", Model.FileId)
                                                                .Column("添加时间", this.DataBaseBuilder.GetDateTime)
                                                                .Column("添加人", Model.Name)
                                                                .Execute();
            }
            catch (Exception ex)
            {
                Logger.Instance.Error("保存产品问题附件表失败", ex);
                return 0;
            }

        }
        #endregion
        /// <summary>
        /// 验证问题
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool AcceptancProblem(ProblemProcessModel model)
        {
            try
            {
                var r = false;
                if (model.Verification)
                {//验证通过
                    r = CompleteAcceptanc(model);
                }
                else
                {
                    //验证不通过
                    r = UndoAcceptanc(model);
                }
                return r;
            }
            catch (Exception ex)
            {
                Logger.Instance.Error("问题验证失败，原因：" + ex);
                return false;
            }

        }

        /// <summary>
        /// 更新版本号
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool UpdateVersion(VersionManageModel model)
        {
            try
            {
                var r = false;
                r =this.UpdateBuilder.Update("问题记录").Where("id", model.问题id).Column("解决版本ID", model.版本ID).Column("解决版本", model.解决版本).Column("解决版本状态", model.解决版本状态)
                    .Column("紧急补丁时间", model.紧急补丁时间).Execute() > 0;
                try
                {
                            if(model.是否加入==1)
                            {
                                var dt = this.SqlBuilder.SqlText("select * from 产品问题版本 t  where 问题ID=:问题id")
                                                    .Parameters("问题id", model.问题id).Select();
                                if(dt.Rows.Count>0)//已经加入，进行更新
                                {
                                    this.DeleteBulider.Delete("产品问题版本").Where("问题ID", model.问题id).Execute();
                                }
                                this.InsertBuilder.Insert("产品问题版本").Column("ID", Guid.NewGuid().ToString())
                                        .Column("问题ID", model.问题id).Column("版本ID", model.版本ID).Column("是否紧急", model.是否紧急)
                                        .Column("产品ID", model.产品ID).Column("说明", model.说明).Column("操作人", model.操作人)
                                        .Column("紧急补丁时间", model.紧急补丁时间).Execute();
                       
                            }
                            else
                                {
                                    this.DeleteBulider.Delete("产品问题版本").Where("问题ID", model.问题id).Execute();
                                }
                }
                catch (Exception ex)
                {
                    Logger.Instance.Error("加入日常补丁失败，原因：" + ex);
                }
                return r;
            }
            catch (Exception ex)
            {
                Logger.Instance.Error("更新问题记录版本号失败，原因：" + ex);
                return false;
            }

        }
      

        /// <summary>
        /// 完成验证
        /// </summary>
        /// <param name="model"></param>
        /// <returns></returns>
        public bool CompleteAcceptanc(ProblemProcessModel model)
        {
            using (var tran = this.DBTransaction.BeginTrans())
            {
                try
                {
                    var dt = this.SqlBuilder.SqlText("Select * from (Select 当前流程ID,记录时间 from 问题记录过程 where 问题ID=:id order by 记录时间 desc) where rownum=1")
                                        .Parameters("id", model.ProblemID).Select();
                    var ProcessId = dt.Rows[0].GetValueByName<int>("当前流程ID");
                    //计算耗时
                    var ProcessTime = dt.Rows[0].GetValueByName<DateTime>("记录时间");
                    DateTime CurrentTime = this.DataBaseBuilder.GetDateTime;
                    TimeSpan time = CurrentTime - ProcessTime;
                    var PassTime = time.TotalMinutes / 60;

                    //更新问题记录
                    var ProblemRecord = this.UpdateBuilder;
                    ProblemRecord.Where("ID", model.ProblemID).Update("问题记录")
                                  .Column("是否验证", 1)
                                  .Column("验证人ID", model.CurrentUserID);
                    //如果填写了问题分类
                    if (!string.IsNullOrEmpty(model.ProblemTypeID))
                    {
                        ProblemRecord.Column("分类ID", model.ProblemTypeID);
                    }
                    var tran1 = ProblemRecord.Execute();
                    //更新问题记录过程
                    var tran2 = this.InsertBuilder.Insert("问题记录过程")
                                                .Column("ID", Guid.NewGuid().ToString())
                                                .Column("问题ID", model.ProblemID)
                                                .Column("记录人ID", model.CurrentUserID)
                                                .Column("记录时间", this.DataBaseBuilder.GetDateTime)
                                                .Column("当前流程ID", ProcessId)
                                                .Column("来源流程ID", ProcessId)
                                                .Column("状态", 11)
                                                .Column("描述", model.ProcessRemark)
                                                .Column("耗时", PassTime)
                                                .Column("结束时间", this.DataBaseBuilder.GetDateTime)
                                                .Execute();
                    tran.CommitTrans();
                    return (tran1 > 0 && tran2 > 0);
                }
                catch (Exception ex)
                {
                    Logger.Instance.Error("调用问题完成验证CompleteAcceptanc失败，原因：" + ex);
                    tran.Rollback();
                    return false;
                }

            }
        }
        /// <summary>
        /// 问题验证不通过，回退完成状态
        /// </summary>
        /// <param name="ProblemId"></param>
        /// <param name="PersonId"></param>
        /// <returns></returns>
        public bool UndoAcceptanc(ProblemProcessModel model)
        {
            using (var tran = this.DBTransaction.BeginTrans())
            {
                try
                {
                    var t = this.UpdateBuilder
                           .Column("是否终止", 0)
                           .Column("是否解决", 0)
                           .Column("终止说明", DBNull.Value)
                           .Column("终止日期", DBNull.Value)
                           .Column("解决方案", DBNull.Value)
                           .Column("是否验证", 0)
                           .Column("验证人ID", DBNull.Value)
                           .Update("问题记录")
                           .Where("ID", model.ProblemID)
                           .Execute(tran);
                    var dt = this.SqlBuilder.SqlText("Select * from (Select 当前流程ID,记录时间 from 问题记录过程 where 问题ID=:id order by 记录时间 desc) where rownum=1")
                                          .Parameters("id", model.ProblemID).Select();
                    var ProcessId = dt.Rows[0].GetValueByName<int>("当前流程ID");
                    //计算耗时
                    var ProcessTime = dt.Rows[0].GetValueByName<DateTime>("记录时间");
                    DateTime CurrentTime = this.DataBaseBuilder.GetDateTime;
                    TimeSpan time = CurrentTime - ProcessTime;
                    var PassTime = time.TotalMinutes / 60;
                    //添加过程
                    var inserProcess = this.InsertBuilder
                                         .Column("ID", Guid.NewGuid().ToString())
                                         .Column("问题ID", model.ProblemID)
                                         .Column("记录人ID", model.CurrentUserID)
                                         .Column("记录时间", CurrentTime)
                                         .Column("当前流程ID", ProcessId)
                                         .Column("状态", 10)
                                         .Column("来源流程ID", ProcessId)
                                         .Column("耗时", PassTime)
                                         .Column("描述", model.ProcessRemark)
                                         .Column("结束时间", CurrentTime)
                                         .Insert("问题记录过程")
                                         .Execute(tran);
                    tran.CommitTrans();
                    return (t > 0 && inserProcess > 0);
                }
                catch (Exception ex)
                {
                    tran.Rollback();
                    Logger.Instance.Error("撤销完成/终止失败", ex);
                    return false;
                }
            }
        }
    }
}