1.通用基础资料：增加模具检验项目、保养项目下拉接口 2.模具管理：点检项目、点检标准、保养项目、保养标准、导入接口

yl

2023-10-13 ecebb28b60d49eeac50dfa3c9a812a0a221e55ae

1.通用基础资料：增加模具检验项目、保养项目下拉接口
2.模具管理：点检项目、点检标准、保养项目、保养标准、导入接口

 VueWebCoreApi/Controllers/GeneralBasicDataController.cs

@@ -234,5 +234,33 @@
            return Json(mes);
        }
        #endregion

        #region[模具检验项目下拉列表]
        /// <summary>
        /// æ¨¡å…·æ£€éªŒé¡¹ç›®ä¸‹æ‹‰åˆ—表
        /// </summary>
        /// <returns></returns>
        [Route(template: "MouldCheckItemSelect")]
        [HttpGet]
        public JsonResult MouldCheckItemSelect()
        {
            mes = GeneralBasicDataBLL.MouldCheckItemSelect();
            return Json(mes);
        }
        #endregion

        #region[模具保养项目下拉列表]
        /// <summary>
        /// æ¨¡å…·ä¿å…»é¡¹ç›®ä¸‹æ‹‰åˆ—表
        /// </summary>
        /// <returns></returns>
        [Route(template: "MouldRepairItemSelect")]
        [HttpGet]
        public JsonResult MouldRepairItemSelect()
        {
            mes = GeneralBasicDataBLL.MouldRepairItemSelect();
            return Json(mes);
        }
        #endregion
    }
}

 VueWebCoreApi/Controllers/MouldManagerController.cs

@@ -153,7 +153,286 @@
        [HttpPost]
        public JsonResult DeleteMouldCheckItem(string checkitemcode)
        {
            mes = MouldManagerBLL.DeleteMouldCheckItem(checkitemcode);
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = MouldManagerBLL.DeleteMouldCheckItem(checkitemcode,us);
            return Json(mes);
        }
        #endregion


        #region[模具点检标准列表查询]
        /// <summary>
        /// æ¨¡å…·ç‚¹æ£€æ ‡å‡†åˆ—表查询
        /// </summary>
        /// <param name="checkstandcode">点检标准编码</param>
        /// <param name="checkstandname">点检标准名称</param>
        /// <param name="checkstandescr">标准要求</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "DeviceCheckStandArdSearch")]
        [HttpGet]
        public JsonResult DeviceCheckStandArdSearch(int page, int rows, string prop, string order, string checkstandcode = null, string checkstandname = null, string checkstandescr = null)
        {
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = MouldManagerBLL.DeviceCheckStandArdSearch(checkstandcode, checkstandname, checkstandescr, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[模具点检标准编辑/查看获取数据]
        /// <summary>
        /// æ¨¡å…·ç‚¹æ£€æ ‡å‡†ç¼–辑/查看获取数据
        /// </summary>
        /// <param name="checkstand_code">模具点检标准编码</param>
        /// <returns></returns>
        [Route(template: "ViewMouldCheckStanedSearch")]
        [HttpPost]
        public JsonResult ViewMouldCheckStanedSearch(string checkstand_code)
        {
            mes = MouldManagerBLL.ViewMouldCheckStanedSearch(checkstand_code);
            return Json(mes);
        }
        #endregion

        #region[模具点检标准新增编辑]
        /// <summary>
        /// æ¨¡å…·ç‚¹æ£€æ ‡å‡†æ–°å¢žç¼–辑
        /// </summary>
        /// <param name="opertype">操作类型</param>
        /// <param name="json">提交数据</param>
        /// <returns></returns>
        [Route(template: "AddUpdateMouldCheckStandArd")]
        [HttpPost]
        public JsonResult AddUpdateMouldCheckStandArd(string opertype, RoutEdit json)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = MouldManagerBLL.AddUpdateMouldCheckStandArd(opertype, json, us);
            return Json(mes);
        }
        #endregion

        #region[模具点检标准删除]
        /// <summary>
        /// æ¨¡å…·ç‚¹æ£€æ ‡å‡†åˆ é™¤
        /// </summary>
        /// <param name="checkstand_code">模具点检标准编码</param>
        /// <returns></returns>
        [Route(template: "DeleteMouldCheckStaned")]
        [HttpPost]
        public JsonResult DeleteDeviceCheckStaned(string checkstand_code)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = MouldManagerBLL.DeleteMouldCheckStaned(checkstand_code,us);
            return Json(mes);
        }
        #endregion

        #region[模具点检标准关联模具查询]
        /// <summary>
        /// æ¨¡å…·ç‚¹æ£€æ ‡å‡†å…³è”模具查询
        /// </summary>
        /// <param name="checkstand_code">模具点检标准编码</param>
        /// <returns></returns>
        [Route(template: "CheckStanedAssociationMould")]
        [HttpGet]
        public JsonResult CheckStanedAssociationMould(string checkstand_code)
        {
            mes = MouldManagerBLL.CheckStanedAssociationMould(checkstand_code);
            return Json(mes);
        }
        #endregion

        #region [模具点检标准关联模具提交]
        /// <summary>
        /// æ¨¡å…·ç‚¹æ£€æ ‡å‡†å…³è”模具提交
        /// </summary>
        /// <param name="checkstand_code">模具点检标准编码</param>
        /// <param name="json">提交数据</param>
        /// <returns></returns>
        [Route(template: "SaveCheckStanedAssociationMould")]
        [HttpPost]
        public JsonResult SaveCheckStanedAssociationMould(string checkstand_code, List<ObjectData> json)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = MouldManagerBLL.SaveCheckStanedAssociationMould(checkstand_code, us, json);
            return Json(mes);
        }
        #endregion


        #region[模具保养项列表查询]
        /// <summary>
        /// æ¨¡å…·ä¿å…»é¡¹åˆ—表查询
        /// </summary>
        /// <param name="maiitemcode">保养部位编码</param>
        /// <param name="maiitemname">保养部位名称</param>
        /// <param name="maidescr">保养要求</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "MouldMaiItemSearch")]
        [HttpGet]
        public JsonResult MouldMaiItemSearch(int page, int rows, string prop, string order, string maiitemcode = null, string maiitemname = null, string maidescr = null)
        {
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = MouldManagerBLL.MouldMaiItemSearch(maiitemcode, maiitemname, maidescr, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[模具保养项新增编辑]
        /// <summary>
        /// æ¨¡å…·ä¿å…»é¡¹æ–°å¢žç¼–辑
        /// </summary>
        /// <param name="obj">提交数据对象</param>
        /// <returns></returns>
        [Route(template: "AddUpdateMouldMaiItem")]
        [HttpPost]
        public JsonResult AddUpdateMouldMaiItem([FromBody] JObject obj)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            string maiitemid = obj["id"].ToString();    //模具保养项id(主键)
            string maiitemcode = obj["maiitemcode"].ToString(); //模具点检部位编码
            string maiitemname = obj["maiitemname"].ToString(); //模具点检部位名称
            string maiitemdescr = obj["maiitemdescr"].ToString(); //模具点检部位要求
            string opertype = obj["opertype"].ToString();  //操作类型
            mes = MouldManagerBLL.AddUpdateMouldMaiItem(maiitemid, maiitemcode, maiitemname, maiitemdescr, us, opertype);
            return Json(mes);
        }
        #endregion

        #region[模具保养项删除]
        /// <summary>
        /// æ¨¡å…·ä¿å…»é¡¹åˆ é™¤
        /// </summary>
        /// <param name="maiitemcode">模具保养项目(部位)编码</param>
        /// <returns></returns>
        [Route(template: "DeleteMouldMaiItem")]
        [HttpPost]
        public JsonResult DeleteMouldMaiItem(string maiitemcode)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = MouldManagerBLL.DeleteMouldMaiItem(maiitemcode, us);
            return Json(mes);
        }
        #endregion


        #region[模具保养标准列表查询]
        /// <summary>
        /// æ¨¡å…·ä¿å…»æ ‡å‡†åˆ—表查询
        /// </summary>
        /// <param name="repairstandcode">保养标准编码</param>
        /// <param name="repairstandname">保养标准名称</param>
        /// <param name="repairstandescr">保准要求</param>
        /// <param name="page">页码</param>
        /// <param name="rows">每页显示条数</param>
        /// <param name="prop">排序字段</param>
        /// <param name="order">排序规则</param>
        /// <returns></returns>
        [Route(template: "MouldRepairStandArdSearch")]
        [HttpGet]
        public JsonResult MouldRepairStandArdSearch(int page, int rows, string prop, string order, string repairstandcode = null, string repairstandname = null, string repairstandescr = null)
        {
            int startNum = rows * (page - 1) + 1;  //起始记录rowNum
            int endNum = rows * page;   //结束记录 rowNum
            mes = MouldManagerBLL.MouldRepairStandArdSearch(repairstandcode, repairstandname, repairstandescr, startNum, endNum, prop, order);
            return Json(mes);
        }
        #endregion

        #region[模具保养标准编辑/查看获取数据]
        /// <summary>
        /// æ¨¡å…·ä¿å…»æ ‡å‡†ç¼–辑/查看获取数据
        /// </summary>
        /// <param name="repairstand_code">模具保养标准编码</param>
        /// <returns></returns>
        [Route(template: "ViewMouldRepairStanedSearch")]
        [HttpPost]
        public JsonResult ViewMouldRepairStanedSearch(string repairstand_code)
        {
            mes = MouldManagerBLL.ViewMouldRepairStanedSearch(repairstand_code);
            return Json(mes);
        }
        #endregion

        #region[模具保养标准新增编辑]
        /// <summary>
        /// æ¨¡å…·ä¿å…»æ ‡å‡†æ–°å¢žç¼–辑
        /// </summary>
        /// <param name="opertype">操作类型</param>
        /// <param name="json">提交数据</param>
        /// <returns></returns>
        [Route(template: "AddUpdateMouldRepairStandArd")]
        [HttpPost]
        public JsonResult AddUpdateMouldRepairStandArd(string opertype, RoutEdit json)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = MouldManagerBLL.AddUpdateMouldRepairStandArd(opertype, json, us);
            return Json(mes);
        }
        #endregion

        #region[模具保养标准删除]
        /// <summary>
        /// æ¨¡å…·ä¿å…»æ ‡å‡†åˆ é™¤
        /// </summary>
        /// <param name="repairstand_code">模具保养标准编码</param>
        /// <returns></returns>
        [Route(template: "DeleteMouldRepairStaned")]
        [HttpPost]
        public JsonResult DeleteMouldRepairStaned(string repairstand_code)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = MouldManagerBLL.DeleteMouldRepairStaned(repairstand_code, us);
            return Json(mes);
        }
        #endregion

        #region[模具保养标准关联模具查询]
        /// <summary>
        /// æ¨¡å…·ä¿å…»æ ‡å‡†å…³è”模具查询
        /// </summary>
        /// <param name="repairstand_code">模具保养标准编码</param>
        /// <returns></returns>
        [Route(template: "RepairStanedAssociationMould")]
        [HttpGet]
        public JsonResult RepairStanedAssociationMould(string repairstand_code)
        {
            mes = MouldManagerBLL.RepairStanedAssociationMould(repairstand_code);
            return Json(mes);
        }
        #endregion

        #region [模具保养标准关联模具提交]
        /// <summary>
        /// æ¨¡å…·ä¿å…»æ ‡å‡†å…³è”模具提交
        /// </summary>
        /// <param name="repairstand_code">模具保养标准编码</param>
        /// <param name="json">提交数据</param>
        /// <returns></returns>
        [Route(template: "SaveRepairStanedAssociationMould")]
        [HttpPost]
        public JsonResult SaveRepairStanedAssociationMould(string repairstand_code, List<ObjectData> json)
        {
            var token = HttpContext.Request.Headers["Token"].ToString();
            User us = JwtTools.Denocode(token.ToString());
            mes = MouldManagerBLL.SaveRepairStanedAssociationMould(repairstand_code, us, json);
            return Json(mes);
        }
        #endregion

 VueWebCoreApi/DLL/BLL/GeneralBasicDataBLL.cs

@@ -122,5 +122,19 @@
            return GeneralBasicDataDAL.InventoryTreePermissions();
        }
        #endregion

        #region[模具检验项目下拉列表]
        public static ToMessage MouldCheckItemSelect()
        {
            return GeneralBasicDataDAL.MouldCheckItemSelect();
        }
        #endregion

        #region[模具保养项目下拉列表]
        public static ToMessage MouldRepairItemSelect()
        {
            return GeneralBasicDataDAL.MouldRepairItemSelect();
        }
        #endregion
    }
}

 VueWebCoreApi/DLL/BLL/MouldManagerBLL.cs

@@ -35,7 +35,7 @@
        #region[模具点检项列表查询]
        public static ToMessage MouldCheckItemSearch(string checkitemcode, string checkitemname, string checkdescr, int startNum, int endNum, string prop, string order)
        {
            return MouldManagerDAL.MouldMangerSearch(checkitemcode, checkitemname, checkdescr, startNum, endNum, prop, order);
            return MouldManagerDAL.MouldCheckItemSearch(checkitemcode, checkitemname, checkdescr, startNum, endNum, prop, order);
        }
        #endregion

@@ -47,9 +47,117 @@
        #endregion

        #region[模具点检项删除]
        public static ToMessage DeleteMouldCheckItem(string checkitemcode)
        public static ToMessage DeleteMouldCheckItem(string checkitemcode,User us)
        {
            return MouldManagerDAL.DeleteMouldCheckItem(checkitemcode);
            return MouldManagerDAL.DeleteMouldCheckItem(checkitemcode,us);
        }
        #endregion


        #region[模具点检标准列表查询]
        public static ToMessage DeviceCheckStandArdSearch(string checkstandcode, string checkstandname, string checkstandescr, int startNum, int endNum, string prop, string order)
        {
            return MouldManagerDAL.DeviceCheckStandArdSearch(checkstandcode, checkstandname, checkstandescr, startNum, endNum, prop, order);
        }
        #endregion

        #region[模具点检标准编辑/查看获取数据]
        public static ToMessage ViewMouldCheckStanedSearch(string checkstand_code)
        {
            return MouldManagerDAL.ViewMouldCheckStanedSearch(checkstand_code);
        }
        #endregion

        #region[模具点检标准新增编辑]
        public static ToMessage AddUpdateMouldCheckStandArd(string opertype, RoutEdit json, User us)
        {
            return MouldManagerDAL.AddUpdateMouldCheckStandArd(opertype, json, us);
        }
        #endregion

        #region[模具点检标准删除]
        public static ToMessage DeleteMouldCheckStaned(string checkstand_code, User us)
        {
            return MouldManagerDAL.DeleteMouldCheckStaned(checkstand_code, us);
        }
        #endregion

        #region[模具点检标准关联模具查询]
        public static ToMessage CheckStanedAssociationMould(string checkstand_code)
        {
            return MouldManagerDAL.CheckStanedAssociationMould(checkstand_code);
        }
        #endregion

        #region [模具点检标准关联模具提交]
        public static ToMessage SaveCheckStanedAssociationMould(string checkstand_code, User us, List<ObjectData> json)
        {
            return MouldManagerDAL.SaveCheckStanedAssociationMould(checkstand_code, us, json);
        }
        #endregion


        #region[模具保养项列表查询]
        public static ToMessage MouldMaiItemSearch(string maiitemcode, string maiitemname, string maidescr, int startNum, int endNum, string prop, string order)
        {
            return MouldManagerDAL.MouldMaiItemSearch(maiitemcode, maiitemname, maidescr, startNum, endNum, prop, order);
        }
        #endregion

        #region[模具保养项新增编辑]
        public static ToMessage AddUpdateMouldMaiItem(string maiitemid, string maiitemcode, string maiitemname, string maiitemdescr, User us, string opertype)
        {
            return MouldManagerDAL.AddUpdateMouldMaiItem(maiitemid, maiitemcode, maiitemname, maiitemdescr, us, opertype);
        }
        #endregion

        #region[模具保养项删除]
        public static ToMessage DeleteMouldMaiItem(string maiitemcode, User us)
        {
            return MouldManagerDAL.DeleteMouldMaiItem(maiitemcode, us);
        }
        #endregion


        #region[模具保养标准列表查询]
        public static ToMessage MouldRepairStandArdSearch(string repairstandcode, string repairstandname, string repairstandescr, int startNum, int endNum, string prop, string order)
        {
            return MouldManagerDAL.MouldRepairStandArdSearch(repairstandcode, repairstandname, repairstandescr, startNum, endNum, prop, order);
        }
        #endregion

        #region[模具保养标准编辑/查看获取数据]
        public static ToMessage ViewMouldRepairStanedSearch(string repairstand_code)
        {
            return MouldManagerDAL.ViewMouldRepairStanedSearch(repairstand_code);
        }
        #endregion

        #region[模具保养标准新增编辑]
        public static ToMessage AddUpdateMouldRepairStandArd(string opertype, RoutEdit json, User us)
        {
            return MouldManagerDAL.AddUpdateMouldRepairStandArd(opertype, json, us);
        }
        #endregion

        #region[模具保养标准删除]
        public static ToMessage DeleteMouldRepairStaned(string repairstand_code, User us)
        {
            return MouldManagerDAL.DeleteMouldRepairStaned(repairstand_code, us);
        }
        #endregion

        #region[模具保养标准关联模具查询]
        public static ToMessage RepairStanedAssociationMould(string repairstand_code)
        {
            return MouldManagerDAL.RepairStanedAssociationMould(repairstand_code);
        }
        #endregion

        #region [模具保养标准关联模具提交]
        public static ToMessage SaveRepairStanedAssociationMould(string repairstand_code, User us, List<ObjectData> json)
        {
            return MouldManagerDAL.SaveRepairStanedAssociationMould(repairstand_code, us, json);
        }
        #endregion
    }

 VueWebCoreApi/DLL/DAL/ExcelCheckDAL.cs

@@ -68,8 +68,14 @@
                case "13"://模具点检项目
                    Message = ImportExcelData.Thirteen(dataTable, out StuCode);
                    break;
                case "14"://工装保养
                    Message = ImportExcelData.Fourteen(savePath, out StuCode);
                case "13_1"://模具点检标准
                    Message = ImportExcelData.Thirteen_one(dataTable, out StuCode);
                    break;
                case "14"://模具保养项目
                    Message = ImportExcelData.Fourteen(dataTable, out StuCode);
                    break;
                case "14_1"://模具保养标准
                    Message = ImportExcelData.Fourteen_one(dataTable, out StuCode);
                    break;
                case "15"://工序定义
                    Message = ImportExcelData.Fifteen(dataTable, out StuCode);
@@ -166,8 +172,14 @@
                case "13"://模具点检项目
                    list = ImportExcelData.ThirteenData(dataTable, out stuCode, out message, out count);
                    break;
                case "14"://工装保养
                    list = ImportExcelData.FourteenData(savePath, out stuCode, out message, out count);
                case "13_1"://模具点检标准
                    list = ImportExcelData.Thirteen_oneData(dataTable, out stuCode, out message, out count);
                    break;
                case "14"://模具保养项目
                    list = ImportExcelData.FourteenData(dataTable, out stuCode, out message, out count);
                    break;
                case "14_1"://模具保养标准
                    list = ImportExcelData.FourteenData_one(dataTable, out stuCode, out message, out count);
                    break;
                case "15"://工序定义
                    list = ImportExcelData.FifteenData(dataTable, out stuCode, out message, out count);
@@ -256,8 +268,14 @@
                case "13"://模具点检项目
                    Message = ImportExcelData.ThirteenSubmit(dataTable, us, out StuCode);
                    break;
                case "14"://工装保养
                    Message = ImportExcelData.FourteenSubmit(savePath, User, out StuCode);
                case "13_1"://模具点检标准
                    Message = ImportExcelData.Thirteen_oneSubmit(dataTable, us, out StuCode);
                    break;
                case "14"://模具保养项目
                    Message = ImportExcelData.FourteenSubmit(dataTable, us, out StuCode);
                    break;
                case "14_1"://模具保养标准
                    Message = ImportExcelData.Fourteen_oneSubmit(dataTable, us, out StuCode);
                    break;
                case "15"://工序定义
                    Message = ImportExcelData.FifteenSubmit(dataTable, us, out StuCode);

 VueWebCoreApi/DLL/DAL/GeneralBasicDataDAL.cs

@@ -444,13 +444,21 @@
            var dynamicParams = new DynamicParameters();
            try
            {
                sql = @"select AA.code,AA.name,isnull(AA.parentid,-1) as parentid   from(
                        select code,name,idparent as parentid   from TMateriel_Class
                        union all
                        select partcode as code,partname as name,idinventoryclass as parentid 
                        from TMateriel_Info 
                        where status='0'
                        ) as AA";
              sql = @"WITH RecursiveCTE AS (
                     SELECT code, name, idparent
                     FROM TMateriel_Class
                     WHERE code in(select distinct idinventoryclass from TMateriel_Info where status='0')
                     UNION ALL
                     SELECT c.code, c.name, c.idparent
                     FROM TMateriel_Class c
                     INNER JOIN RecursiveCTE r ON c.code = r.idparent
                   )
                   SELECT distinct code, name, idparent as parentid
                   FROM RecursiveCTE CTE
                   union all
                   select partcode as code,partname as name,idinventoryclass as parentid 
                   from TMateriel_Info 
                   where status='0'";
                var data = DapperHelper.selectdata(sql, dynamicParams);
                mes.code = "200";
                mes.Message = "查询成功!";
@@ -466,5 +474,53 @@
            return mes;
        }
        #endregion

        #region[模具检验项目下拉列表]
        public static ToMessage MouldCheckItemSelect()
        {
            string sql = "";
            try
            {
                //获取模具点检项目数据
                sql = @"select code,name,description from TMouldchk_Item";
                var data = DapperHelper.selecttable(sql);
                mes.code = "200";
                mes.Message = "查询成功!";
                mes.data = data;
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具保养项目下拉列表]
        public static ToMessage MouldRepairItemSelect()
        {
            string sql = "";
            try
            {
                //获取模具保养项目数据
                sql = @"select code,name,description from TMouldmai_Item";
                var data = DapperHelper.selecttable(sql);
                mes.code = "200";
                mes.Message = "查询成功!";
                mes.data = data;
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion
    }
}

 VueWebCoreApi/DLL/DAL/MouldManagerDAL.cs

@@ -34,7 +34,7 @@
                }
                if (onstate != "" && onstate != null)
                {
                    search += "and A.usestaus=@onstate ";
                    search += "and A.usestatus=@onstate ";
                    dynamicParams.Add("@onstate", onstate);
                }
                if (mouldcode != "" && mouldcode != null)
@@ -69,7 +69,7 @@
                }
                // --------------查询指定数据--------------
                var total = 0; //总条数
                var sql = @"select A.status,A.usestaus,A.code,A.name,A.spec,A.warehousecode,S.name as warehousename,
                var sql = @"select A.status,A.usestatus,A.code,A.name,A.spec,A.warehousecode,S.name as warehousename,
                            A.surp_life,'0' as serlife,A.resi_life,(case when isnull(M.mouldcode,'')='' then 'N' else 'Y' end) as is_part,
                            STUFF((SELECT ',' + B.partcode
                            from TMouldInfoPart B
@@ -110,7 +110,7 @@
            {
                if (opertype == "Add")
                {
                    //写入模具清单表
                    //写入模具清单表                                     
                    sql = @"insert into TMouldInfo(code,name,spec,status,usestatus,warehousecode,surp_life,resi_life,lm_user,lm_date) 
                               values(@code,@name,@spec,@status,@usestatus,@warehousecode,@surp_life,@resi_life,@lm_user,@lm_date)";
                    list.Add(new
@@ -286,6 +286,8 @@
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    //写入操作记录表
                    LogHelper.DbOperateLog(us.usercode, "删除", "模具:" + mouldcode, us.usertype);
                    mes.code = "200";
                    mes.count = 0;
                    mes.Message = "删除成功!";
@@ -313,7 +315,7 @@


        #region[模具点检项列表查询]
        public static ToMessage MouldMangerSearch(string checkitemcode, string checkitemname, string checkdescr, int startNum, int endNum, string prop, string order)
        public static ToMessage MouldCheckItemSearch(string checkitemcode, string checkitemname, string checkdescr, int startNum, int endNum, string prop, string order)
        {
            var dynamicParams = new DynamicParameters();
            string search = "";
@@ -380,6 +382,8 @@
                    int cont = DapperHelper.SQL(sql, dynamicParams);
                    if (cont > 0)
                    {
                        //写入操作记录表
                        LogHelper.DbOperateLog(us.usercode, "新增", "模具点检项:" + checkitemcode, us.usertype);
                        mes.code = "200";
                        mes.count = 0;
                        mes.Message = "新增操作成功!";
@@ -406,6 +410,8 @@
                    int cont = DapperHelper.SQL(sql, dynamicParams);
                    if (cont > 0)
                    {
                        //写入操作记录表
                        LogHelper.DbOperateLog(us.usercode, "修改", "模具点检项:" + checkitemcode, us.usertype);
                        mes.code = "200";
                        mes.count = 0;
                        mes.Message = "修改操作成功!";
@@ -432,7 +438,7 @@
        #endregion

        #region[模具点检项删除]
        public static ToMessage DeleteMouldCheckItem(string checkitemcode)
        public static ToMessage DeleteMouldCheckItem(string checkitemcode,User us)
        {
            var sql = "";
            List<object> list = new List<object>();
@@ -460,6 +466,8 @@
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    //写入操作记录表
                    LogHelper.DbOperateLog(us.usercode, "删除", "模具点检项:" + checkitemcode, us.usertype);
                    mes.code = "200";
                    mes.count = 0;
                    mes.Message = "删除成功!";
@@ -485,5 +493,959 @@
        }
        #endregion


        #region[模具点检标准列表查询]
        public static ToMessage DeviceCheckStandArdSearch(string checkstandcode, string checkstandname, string checkstandescr, int startNum, int endNum, string prop, string order)
        {
            var dynamicParams = new DynamicParameters();
            string search = "";
            try
            {
                if (checkstandcode != "" && checkstandcode != null)
                {
                    search += "and A.code like '%'+@checkstandcode+'%' ";
                    dynamicParams.Add("@checkstandcode", checkstandcode);
                }
                if (checkstandname != "" && checkstandname != null)
                {
                    search += "and A.name like '%'+@checkstandname+'%' ";
                    dynamicParams.Add("@checkstandname", checkstandname);
                }
                if (checkstandescr != "" && checkstandescr != null)
                {
                    search += "and A.iscontr=@checkstandescr ";
                    dynamicParams.Add("@checkstandescr", checkstandescr);
                }
                if (search == "")
                {
                    search = "and 1=1 ";
                }
                //search = search.Substring(3);//截取索引2后面的字符
                // --------------查询指定数据--------------
                var total = 0; //总条数
                var sql = @"select A.id,A.code,A.name,A.description,A.is_checkmould,U.username as lm_user,A.lm_date 
                            from TMouldchk_Main A
                            left join TUser U on A.lm_user=U.usercode
                            where 1=1 " + search;
                var data = DapperHelper.GetPageList<object>(sql, dynamicParams, prop, order, startNum, endNum, out total);
                mes.code = "200";
                mes.Message = "查询成功!";
                mes.count = total;
                mes.data = data.ToList();
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具点检标准编辑/查看获取数据]
        public static ToMessage ViewMouldCheckStanedSearch(string checkstand_code)
        {
            string sql = "";
            var dynamicParams = new DynamicParameters();
            try
            {
                //获取模具点检标准信息
                sql = @"select code,name,description
                        from TMouldchk_Main
                        where code=@checkstand_code";
                dynamicParams.Add("@checkstand_code", checkstand_code);
                var data = DapperHelper.selectdata(sql, dynamicParams);
                RoutEdit rout = new RoutEdit();
                if (data.Rows.Count > 0)
                {
                    rout.code = data.Rows[0]["CODE"].ToString();
                    rout.name = data.Rows[0]["NAME"].ToString();
                    rout.description = data.Rows[0]["DESCRIPTION"].ToString();
                }
                else
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "无点检标准信息!";
                    mes.data = null;
                    return mes;
                }
                //根据模具点检标准编码获取关联的检验项目信息
                sql = @"select B.code,B.name,A.chkdesc from TMouldchk_Deta A
                        left join TMouldchk_Item  B on A.code=B.code
                        where  A.mouldchk_main_code=@checkstaned_code order by A.seq asc";
                dynamicParams.Add("@checkstaned_code", rout.code);
                var data0 = DapperHelper.selectdata(sql, dynamicParams);
                rout.Data = data0;

                mes.code = "200";
                mes.Message = "查询成功!";
                mes.data = rout;
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具点检标准新增编辑]
        public static ToMessage AddUpdateMouldCheckStandArd(string opertype, RoutEdit json, User us)
        {
            var sql = "";
            var dynamicParams = new DynamicParameters();
            List<object> list = new List<object>();
            try
            {
                if (opertype == "Add")
                {
                    //新增模具点检标准主表
                    sql = @"insert into TMouldchk_Main(code,name,description,lm_user,lm_date) values(@code,@name,@descr,@lm_user,@lm_date)";
                    list.Add(new { str = sql, parm = new { code = json.code, name = json.name, descr = json.description,lm_user = us.usercode, lm_date = DateTime.Now.ToString() } });
                    for (int i = 0; i < json.Data.Rows.Count; i++)
                    {
                        //新增模具点检标准关联点检项子表
                        sql = @"insert TMouldchk_Deta (seq,code,name,mouldchk_main_code,chkdesc,lm_user,lm_date) 
                                values(@checkitem_seq,@checkitem_code,@checkitem_name,@mouldchk_main_code,@chkdesc,@lm_user,@lm_date)";
                        list.Add(new
                        {
                            str = sql,
                            parm = new
                            {
                                checkitem_seq = Convert.ToInt32(json.Data.Rows[i]["CHECKITEM_SEQ"].ToString()),
                                checkitem_code = json.Data.Rows[i]["CHECKITEM_CODE"].ToString(),
                                checkitem_name = json.Data.Rows[i]["CHECKITEM_NAME"].ToString(),
                                mouldchk_main_code = json.code,
                                chkdesc = json.Data.Rows[i]["CHECKITEM_DESCR"].ToString(),
                                lm_user = us.usercode,
                                lm_date = DateTime.Now.ToString()
                            }
                        });
                    }
                    bool aa = DapperHelper.DoTransaction(list);
                    if (aa)
                    {
                        //写入操作记录表
                        LogHelper.DbOperateLog(us.usercode, "新增", "模具点检标准:" + json.code, us.usertype);
                        mes.code = "200";
                        mes.count = 0;
                        mes.Message = "操作成功!";
                        mes.data = null;
                    }
                    else
                    {
                        mes.code = "300";
                        mes.count = 0;
                        mes.Message = "操作失败!";
                        mes.data = null;
                    }
                }
                if (opertype == "Update")
                {
                    //删除点检标准关联点检项目子表
                    sql = @"delete from TMouldchk_Deta where mouldchk_main_code=@checkstaned_code";
                    list.Add(new { str = sql, parm = new { checkstaned_code = json.code } });
                    //修改点检标准主表
                    sql = @"update  TMouldchk_Main set name=@checkstaned_name,description=@checkstaned_desc where code=@checkstaned_code";
                    list.Add(new { str = sql, parm = new { checkstaned_code = json.code, checkstaned_name = json.name, checkstaned_desc = json.description} });
                    //新增点检标准关联点检项目子表
                    for (int i = 0; i < json.Data.Rows.Count; i++)
                    {
                        sql = @"insert TMouldchk_Deta (seq,code,name,mouldchk_main_code,chkdesc,lm_user,lm_date) 
                                values(@checkitem_seq,@checkitem_code,@checkitem_name,@mouldchk_main_code,@chkdesc,@lm_user,@lm_date)";
                        list.Add(new
                        {
                            str = sql,
                            parm = new
                            {
                                checkitem_seq = Convert.ToInt32(json.Data.Rows[i]["CHECKITEM_SEQ"].ToString()),
                                checkitem_code = json.Data.Rows[i]["CHECKITEM_CODE"].ToString(),
                                checkitem_name = json.Data.Rows[i]["CHECKITEM_NAME"].ToString(),
                                mouldchk_main_code = json.code,
                                chkdesc = json.Data.Rows[i]["CHECKITEM_DESCR"].ToString(),
                                lm_user = us.usercode,
                                lm_date = DateTime.Now.ToString()
                            }
                        });
                    }

                    bool aa = DapperHelper.DoTransaction(list);
                    if (aa)
                    {
                        //写入操作记录表
                        LogHelper.DbOperateLog(us.usercode, "修改", "模具点检标准:" + json.code, us.usertype);
                        mes.code = "200";
                        mes.count = 0;
                        mes.Message = "操作成功!";
                        mes.data = null;
                    }
                    else
                    {
                        mes.code = "300";
                        mes.count = 0;
                        mes.Message = "操作失败!";
                        mes.data = null;
                    }
                }
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具点检标准删除]
        public static ToMessage DeleteMouldCheckStaned(string checkstand_code, User us)
        {
            var sql = "";
            List<object> list = new List<object>();
            var dynamicParams = new DynamicParameters();
            try
            {
                sql = @"select * from  TMouldchk_Proc_Main  where mouldchkmain_code=@checkstand_code";
                dynamicParams.Add("@checkstand_code", checkstand_code);
                var data = DapperHelper.selectdata(sql, dynamicParams);
                if (data.Rows.Count > 0)
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "当前点检标准已生成点检记录,不允许删除!";
                    mes.data = null;
                    return mes;
                }
                //删除模具点检标准主表
                sql = @"delete TMouldchk_Main  where code=@checkstand_code";
                list.Add(new { str = sql, parm = new { checkstand_code = checkstand_code } });
                //删除模具点检标准关联点检项目子表
                sql = @"delete TMouldchk_Deta  where mouldchk_main_code=@checkstand_code";
                list.Add(new { str = sql, parm = new { checkstand_code = checkstand_code } });
                //删除模具点检标准关联模具表
                sql = @"delete TMouldchk_Mould  where mouldchkmain_code=@checkstand_code";
                list.Add(new { str = sql, parm = new { checkstand_code = checkstand_code } });
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    //写入操作记录表
                    LogHelper.DbOperateLog(us.usercode, "删除", "模具点检标准:" + checkstand_code, us.usertype);
                    mes.code = "200";
                    mes.count = 0;
                    mes.Message = "设备点检标准删除成功!";
                    mes.data = null;
                }
                else
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "设备点检标准删除失败!";
                    mes.data = null;
                }
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具点检标准关联模具查询]
        public static ToMessage CheckStanedAssociationMould(string checkstand_code)
        {
            string sql = "";
            var dynamicParams = new DynamicParameters();
            try
            {
                sql = @"select *  from(
                        select AA.code,AA.name,'M' as type,(case when BB.mouldchkmain_code is null then 'N' else 'Y' end) flag
                        from(
                        select A.code,A.name,'' as mouldchkmain_code
                        from TMouldInfo A
                        where  A.status='Y'
                        ) as AA
                        left join (
                         select A.code,A.name,B.mouldchkmain_code
                         from TMouldInfo A
                         inner join TMouldchk_Mould B on A.code=B.mould_code
                         where  B.mouldchkmain_code=@checkstand_code and A.status='Y'
                        ) as BB on AA.code=BB.code
                        ) as CC";
                dynamicParams.Add("@checkstand_code", checkstand_code);
                var data = DapperHelper.selectdata(sql, dynamicParams);
                if (data.Rows.Count > 0)
                {
                    mes.code = "200";
                    mes.Message = "查询成功!";
                    mes.data = data;
                }
                else 
                {
                    mes.code = "300";
                    mes.Message = "无模具资料!";
                    mes.data = null;
                }
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region [模具点检标准关联模具提交]
        public static ToMessage SaveCheckStanedAssociationMould(string checkstand_code, User us, List<ObjectData> json)
        {
            var sql = "";
            List<object> list = new List<object>();
            try
            {
                list.Clear();
                if (json == null || json.Count <= 0)
                {
                    //清除模具点检标准关联模具表数据
                    sql = @"delete TMouldchk_Mould where mouldchkmain_code=@checkstand_code";
                    list.Add(new { str = sql, parm = new { checkstand_code = checkstand_code } });
                    //标记模具点检标准表关联模具标识
                    sql = @"update TMouldchk_Main set is_checkmould='N' where code=@checkstand_code";
                    list.Add(new { str = sql, parm = new { checkstand_code = checkstand_code } });
                }
                else
                {
                    //清除模具点检标准关联模具表数据
                    sql = @"delete TMouldchk_Mould where mouldchkmain_code=@checkstand_code";
                    list.Add(new { str = sql, parm = new { checkstand_code = checkstand_code } });
                    //循环写入模具点检标准关联模具表
                    for (int i = 0; i < json.Count; i++)
                    {
                        sql = @"insert into TMouldchk_Mould(mouldchkmain_code,mould_code,lm_user,lm_date) values(@checkstand_code,@mould_code,@lm_user,@lm_date)";
                        list.Add(new
                        {
                            str = sql,
                            parm = new
                            {
                                mould_code = json[i].code,
                                checkstand_code = checkstand_code,
                                lm_user = us.usercode,
                                lm_date = DateTime.Now.ToString()
                            }
                        });
                    }
                    //标记模具点检标准表关联模具标识
                    sql = @"update TMouldchk_Main set is_checkmould='Y' where code=@checkstand_code";
                    list.Add(new { str = sql, parm = new { checkstand_code = checkstand_code } });
                }
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    //写入操作记录表
                    LogHelper.DbOperateLog(us.usercode, "模具点检标准关联模具", "模具点检标准:" + checkstand_code, us.usertype);
                    mes.code = "200";
                    mes.count = 0;
                    mes.Message = "操作成功!";
                    mes.data = null;
                }
                else
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "操作失败!";
                    mes.data = null;
                }
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion


        #region[模具保养项列表查询]
        public static ToMessage MouldMaiItemSearch(string maiitemcode, string maiitemname, string maidescr, int startNum, int endNum, string prop, string order)
        {
            var dynamicParams = new DynamicParameters();
            string search = "";
            try
            {
                if (maiitemcode != "" && maiitemcode != null)
                {
                    search += "and A.code like '%'+@maiitemcode+'%' ";
                    dynamicParams.Add("@maiitemcode", maiitemcode);
                }
                if (maiitemname != "" && maiitemname != null)
                {
                    search += "and A.name like '%'+@maiitemname+'%' ";
                    dynamicParams.Add("@maiitemname", maiitemname);
                }
                if (maidescr != "" && maidescr != null)
                {
                    search += "and A.description like '%'+@maidescr+'%' ";
                    dynamicParams.Add("@maidescr", maidescr);
                }
                if (search == "")
                {
                    search = "and 1=1 ";
                }
                //search = search.Substring(3);//截取索引2后面的字符
                // --------------查询指定数据--------------
                var total = 0; //总条数
                var sql = @"select A.id,A.code,A.name,A.description,U.username as lm_user,A.lm_date 
                                from TMouldmai_Item A
                                left join TUser U on A.lm_user=U.usercode
                                where 1=1 " + search;
                var data = DapperHelper.GetPageList<object>(sql, dynamicParams, prop, order, startNum, endNum, out total);
                mes.code = "200";
                mes.Message = "查询成功!";
                mes.count = total;
                mes.data = data.ToList();
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具保养项新增编辑]
        public static ToMessage AddUpdateMouldMaiItem(string maiitemid, string maiitemcode, string maiitemname, string maiitemdescr, User us, string opertype)
        {
            var dynamicParams = new DynamicParameters();
            try
            {
                if (opertype == "Add")
                {
                    var sql = @"insert into TMouldmai_Item(code,name,description,lm_user,lm_date) 
                              values(@maiitemcode,@maiitemname,@maiitemdescr,@usercode,@CreateDate)";
                    dynamicParams.Add("@maiitemcode", maiitemcode);
                    dynamicParams.Add("@maiitemname", maiitemname);
                    dynamicParams.Add("@maiitemdescr", maiitemdescr);
                    dynamicParams.Add("@usercode", us.usercode);
                    dynamicParams.Add("@CreateDate", DateTime.Now.ToString());
                    int cont = DapperHelper.SQL(sql, dynamicParams);
                    if (cont > 0)
                    {
                        //写入操作记录表
                        LogHelper.DbOperateLog(us.usercode, "新增", "模具保养项:" + maiitemcode, us.usertype);
                        mes.code = "200";
                        mes.count = 0;
                        mes.Message = "新增操作成功!";
                        mes.data = null;
                    }
                    else
                    {
                        mes.code = "300";
                        mes.count = 0;
                        mes.Message = "新增操作失败!";
                        mes.data = null;
                    }
                }
                if (opertype == "Update")
                {
                    var sql = @"update TMouldmai_Item set name=@maiitemname,description=@maiitemdescr,
                                lm_user=@usercode,lm_date=@CreateDate
                                where id=@maiitemid";
                    dynamicParams.Add("@maiitemid", maiitemid);
                    dynamicParams.Add("@maiitemname", maiitemname);
                    dynamicParams.Add("@maiitemdescr", maiitemdescr);
                    dynamicParams.Add("@usercode", us.usercode);
                    dynamicParams.Add("@CreateDate", DateTime.Now.ToString());
                    int cont = DapperHelper.SQL(sql, dynamicParams);
                    if (cont > 0)
                    {
                        //写入操作记录表
                        LogHelper.DbOperateLog(us.usercode, "修改", "模具保养项:" + maiitemcode, us.usertype);
                        mes.code = "200";
                        mes.count = 0;
                        mes.Message = "修改操作成功!";
                        mes.data = null;
                    }
                    else
                    {
                        mes.code = "300";
                        mes.count = 0;
                        mes.Message = "修改操作失败!";
                        mes.data = null;
                    }
                }
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具保养项删除]
        public static ToMessage DeleteMouldMaiItem(string maiitemcode, User us)
        {
            var sql = "";
            List<object> list = new List<object>();
            var dynamicParams = new DynamicParameters();
            try
            {
                list.Clear();
                //判断保养标准项目是否有关联保养标准,不允许删除
                sql = @"select *  from TMouldmai_Deta
                        where  code=@checkitemcode";
                dynamicParams.Add("@maiitemcode", maiitemcode);
                var data = DapperHelper.selectdata(sql, dynamicParams);
                if (data.Rows.Count > 0)
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "当前保养项目已关联标准,不允许删除!";
                    mes.data = null;
                    return mes;
                }

                //删除保养项目
                sql = @"delete TMouldmai_Item  where code=@maiitemcode";
                list.Add(new { str = sql, parm = new { maiitemcode = maiitemcode } });
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    //写入操作记录表
                    LogHelper.DbOperateLog(us.usercode, "删除", "模具保养项:" + maiitemcode, us.usertype);
                    mes.code = "200";
                    mes.count = 0;
                    mes.Message = "删除成功!";
                    mes.data = null;
                }
                else
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "删除失败!";
                    mes.data = null;
                }

            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion


        #region[模具保养标准列表查询]
        public static ToMessage MouldRepairStandArdSearch(string repairstandcode, string repairstandname, string repairstandescr, int startNum, int endNum, string prop, string order)
        {
            var dynamicParams = new DynamicParameters();
            string search = "";
            try
            {
                if (repairstandcode != "" && repairstandcode != null)
                {
                    search += "and A.code like '%'+@repairstandcode+'%' ";
                    dynamicParams.Add("@repairstandcode", repairstandcode);
                }
                if (repairstandname != "" && repairstandname != null)
                {
                    search += "and A.name like '%'+@repairstandname+'%' ";
                    dynamicParams.Add("@repairstandname", repairstandname);
                }
                if (repairstandescr != "" && repairstandescr != null)
                {
                    search += "and A.iscontr=@repairstandescr ";
                    dynamicParams.Add("@repairstandescr", repairstandescr);
                }
                if (search == "")
                {
                    search = "and 1=1 ";
                }
                //search = search.Substring(3);//截取索引2后面的字符
                // --------------查询指定数据--------------
                var total = 0; //总条数
                var sql = @"select A.id,A.code,A.name,A.description,A.is_repairmould,U.username as lm_user,A.lm_date 
                            from TMouldmai_Main A
                            left join TUser U on A.lm_user=U.usercode
                            where 1=1 " + search;
                var data = DapperHelper.GetPageList<object>(sql, dynamicParams, prop, order, startNum, endNum, out total);
                mes.code = "200";
                mes.Message = "查询成功!";
                mes.count = total;
                mes.data = data.ToList();
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具保养标准编辑/查看获取数据]
        public static ToMessage ViewMouldRepairStanedSearch(string repairstand_code)
        {
            string sql = "";
            var dynamicParams = new DynamicParameters();
            try
            {
                //获取模具保养标准信息
                sql = @"select code,name,description
                        from TMouldmai_Main
                        where code=@repairstand_code";
                dynamicParams.Add("@repairstand_code", repairstand_code);
                var data = DapperHelper.selectdata(sql, dynamicParams);
                RoutEdit rout = new RoutEdit();
                if (data.Rows.Count > 0)
                {
                    rout.code = data.Rows[0]["CODE"].ToString();
                    rout.name = data.Rows[0]["NAME"].ToString();
                    rout.description = data.Rows[0]["DESCRIPTION"].ToString();
                }
                else
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "无点检标准信息!";
                    mes.data = null;
                    return mes;
                }
                //根据模具保养标准编码获取关联的检验项目信息
                sql = @"select B.code,B.name,A.chkdesc from TMouldmai_Deta A
                        left join TMouldchk_Item  B on A.code=B.code
                        where  A.mouldmai_main_code=@repairstand_code order by A.seq asc";
                dynamicParams.Add("@repairstand_code", rout.code);
                var data0 = DapperHelper.selectdata(sql, dynamicParams);
                rout.Data = data0;

                mes.code = "200";
                mes.Message = "查询成功!";
                mes.data = rout;
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具保养标准新增编辑]
        public static ToMessage AddUpdateMouldRepairStandArd(string opertype, RoutEdit json, User us)
        {
            var sql = "";
            var dynamicParams = new DynamicParameters();
            List<object> list = new List<object>();
            try
            {
                if (opertype == "Add")
                {
                    //新增模具保养标准主表
                    sql = @"insert into TMouldmai_Main(code,name,description,lm_user,lm_date) values(@code,@name,@descr,@lm_user,@lm_date)";
                    list.Add(new { str = sql, parm = new { code = json.code, name = json.name, descr = json.description, lm_user = us.usercode, lm_date = DateTime.Now.ToString() } });
                    for (int i = 0; i < json.Data.Rows.Count; i++)
                    {
                        //新增模具保养标准关联保养项子表
                        sql = @"insert TMouldmai_Deta (seq,code,name,mouldmai_main_code,chkdesc,lm_user,lm_date) 
                                values(@checkitem_seq,@checkitem_code,@mouldmai_main_code,@chkdesc,@lm_user,@lm_date)";
                        list.Add(new
                        {
                            str = sql,
                            parm = new
                            {
                                checkitem_seq = Convert.ToInt32(json.Data.Rows[i]["CHECKITEM_SEQ"].ToString()),
                                checkitem_code = json.Data.Rows[i]["CHECKITEM_CODE"].ToString(),
                                checkitem_name = json.Data.Rows[i]["CHECKITEM_NAME"].ToString(),
                                mouldmai_main_code=json.code,
                                chkdesc = json.Data.Rows[i]["CHECKITEM_DESCR"].ToString(),
                                lm_user = us.usercode,
                                lm_date = DateTime.Now.ToString()
                            }
                        });
                    }
                    bool aa = DapperHelper.DoTransaction(list);
                    if (aa)
                    {
                        //写入操作记录表
                        LogHelper.DbOperateLog(us.usercode, "新增", "模具保养标准:" + json.code, us.usertype);
                        mes.code = "200";
                        mes.count = 0;
                        mes.Message = "操作成功!";
                        mes.data = null;
                    }
                    else
                    {
                        mes.code = "300";
                        mes.count = 0;
                        mes.Message = "操作失败!";
                        mes.data = null;
                    }
                }
                if (opertype == "Update")
                {
                    //删除保养标准关联保养项目子表
                    sql = @"delete from TMouldmai_Deta where mouldmai_main_code=@repairstaned_code";
                    list.Add(new { str = sql, parm = new { repairstaned_code = json.code } });
                    //修改保养标准主表
                    sql = @"update  TMouldmai_Main set name=@checkstaned_name,description=@checkstaned_desc where code=@repairstaned_code";
                    list.Add(new { str = sql, parm = new { repairstaned_code = json.code, checkstaned_name = json.name, checkstaned_desc = json.description } });
                    //新增保养标准关联保养项目子表
                    for (int i = 0; i < json.Data.Rows.Count; i++)
                    {
                        sql = @"insert TMouldmai_Deta (seq,code,name,mouldmai_main_code,chkdesc,lm_user,lm_date) 
                                values(@checkitem_seq,@checkitem_code,@checkitem_name,@mouldmai_main_code,@chkdesc,@lm_user,@lm_date)";
                        list.Add(new
                        {
                            str = sql,
                            parm = new
                            {
                                checkitem_seq = Convert.ToInt32(json.Data.Rows[i]["CHECKITEM_SEQ"].ToString()),
                                checkitem_code = json.Data.Rows[i]["CHECKITEM_CODE"].ToString(),
                                checkitem_name = json.Data.Rows[i]["CHECKITEM_NAME"].ToString(),
                                mouldmai_main_code = json.code,
                                chkdesc = json.Data.Rows[i]["CHECKITEM_DESCR"].ToString(),
                                lm_user = us.usercode,
                                lm_date = DateTime.Now.ToString()
                            }
                        });
                    }

                    bool aa = DapperHelper.DoTransaction(list);
                    if (aa)
                    {
                        //写入操作记录表
                        LogHelper.DbOperateLog(us.usercode, "修改", "模具保养标准:" + json.code, us.usertype);
                        mes.code = "200";
                        mes.count = 0;
                        mes.Message = "操作成功!";
                        mes.data = null;
                    }
                    else
                    {
                        mes.code = "300";
                        mes.count = 0;
                        mes.Message = "操作失败!";
                        mes.data = null;
                    }
                }
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具保养标准删除]
        public static ToMessage DeleteMouldRepairStaned(string repairstand_code, User us)
        {
            var sql = "";
            List<object> list = new List<object>();
            var dynamicParams = new DynamicParameters();
            try
            {
                sql = @"select * from  TMouldmaint_Proc_Main  where mouldmaint_code=@repairstand_code";
                dynamicParams.Add("@repairstand_code", repairstand_code);
                var data = DapperHelper.selectdata(sql, dynamicParams);
                if (data.Rows.Count > 0)
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "当前保养标准已生成点检记录,不允许删除!";
                    mes.data = null;
                    return mes;
                }
                //删除模具保养标准主表
                sql = @"delete TMouldmai_Main  where code=@repairstand_code";
                list.Add(new { str = sql, parm = new { repairstand_code = repairstand_code } });
                //删除模具保养标准关联保养项目子表
                sql = @"delete TMouldmai_Deta  where mouldmai_main_code=@repairstand_code";
                list.Add(new { str = sql, parm = new { repairstand_code = repairstand_code } });
                //删除模具保养标准关联模具表
                sql = @"delete TMouldmai_Mould  where mouldmaimain_code=@repairstand_code";
                list.Add(new { str = sql, parm = new { repairstand_code = repairstand_code } });
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    //写入操作记录表
                    LogHelper.DbOperateLog(us.usercode, "删除", "模具保养标准:" + repairstand_code, us.usertype);
                    mes.code = "200";
                    mes.count = 0;
                    mes.Message = "模具保养标准删除成功!";
                    mes.data = null;
                }
                else
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "模具保养标准删除失败!";
                    mes.data = null;
                }
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region[模具点检标准关联模具查询]
        public static ToMessage RepairStanedAssociationMould(string repairstand_code)
        {
            string sql = "";
            var dynamicParams = new DynamicParameters();
            try
            {
                sql = @"select *  from(
                        select AA.code,AA.name,'M' as type,(case when BB.mouldmaimain_code is null then 'N' else 'Y' end) flag
                        from(
                        select A.code,A.name,'' as mouldmaimain_code
                        from TMouldInfo A
                        where  A.status='Y'
                        ) as AA
                        left join (
                         select A.code,A.name,B.mouldmaimain_code
                         from TMouldInfo A
                         inner join TMouldmai_Mould B on A.code=B.mould_code
                         where  B.mouldmaimain_code=@repairstand_code and A.status='Y'
                        ) as BB on AA.code=BB.code
                        ) as CC";
                dynamicParams.Add("@repairstand_code", repairstand_code);
                var data = DapperHelper.selectdata(sql, dynamicParams);
                if (data.Rows.Count > 0)
                {
                    mes.code = "200";
                    mes.Message = "查询成功!";
                    mes.data = data;
                }
                else
                {
                    mes.code = "300";
                    mes.Message = "无模具资料!";
                    mes.data = null;
                }
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

        #region [模具点检标准关联模具提交]
        public static ToMessage SaveRepairStanedAssociationMould(string repairstand_code, User us, List<ObjectData> json)
        {
            var sql = "";
            List<object> list = new List<object>();
            try
            {
                list.Clear();
                if (json == null || json.Count <= 0)
                {
                    //清除模具保养标准关联模具表数据
                    sql = @"delete TMouldmai_Mould where mouldmaimain_code=@repairstand_code";
                    list.Add(new { str = sql, parm = new { repairstand_code = repairstand_code } });
                    //标记模具保养标准表关联模具标识
                    sql = @"update TMouldmai_Main set is_repairmould='N' where code=@repairstand_code";
                    list.Add(new { str = sql, parm = new { repairstand_code = repairstand_code } });
                }
                else
                {
                    //清除模具保养标准关联模具表数据
                    sql = @"delete TMouldmai_Mould where mouldmaimain_code=@repairstand_code";
                    list.Add(new { str = sql, parm = new { repairstand_code = repairstand_code } });
                    //循环写入模具保养标准关联模具表
                    for (int i = 0; i < json.Count; i++)
                    {
                        sql = @"insert into TMouldmai_Mould(mouldmaimain_code,mould_code,lm_user,lm_date) values(@repairstand_code,@mould_code,@lm_user,@lm_date)";
                        list.Add(new
                        {
                            str = sql,
                            parm = new
                            {
                                mould_code = json[i].code,
                                repairstand_code = repairstand_code,
                                lm_user = us.usercode,
                                lm_date = DateTime.Now.ToString()
                            }
                        });
                    }
                    //标记模具保养标准表关联模具标识
                    sql = @"update TMouldmai_Main set is_repairmould='Y' where code=@repairstand_code";
                    list.Add(new { str = sql, parm = new { repairstand_code = repairstand_code } });
                }
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    //写入操作记录表
                    LogHelper.DbOperateLog(us.usercode, "模具保养标准关联模具", "模具保养标准:" + repairstand_code, us.usertype);
                    mes.code = "200";
                    mes.count = 0;
                    mes.Message = "操作成功!";
                    mes.data = null;
                }
                else
                {
                    mes.code = "300";
                    mes.count = 0;
                    mes.Message = "操作失败!";
                    mes.data = null;
                }
            }
            catch (Exception e)
            {
                mes.code = "300";
                mes.count = 0;
                mes.Message = e.Message;
                mes.data = null;
            }
            return mes;
        }
        #endregion

    }
}

 VueWebCoreApi/Tools/ImportExcelData.cs

@@ -1063,25 +1063,25 @@
                Message = "模具清单模板：表头信息不符合规范,第1列应为{*模具编号(唯一)}";
                return Message;
            }
            else if (excelTable[1].Columns[1].ColumnName != "*模具名称")
            else if (excelTable[0].Columns[1].ColumnName != "*模具名称")
            {
                code = "301";
                Message = "模具清单模板：表头信息不符合规范,第2列应为{*模具名称}";
                return Message;
            }
            else if (excelTable[1].Columns[2].ColumnName != "规格型号")
            else if (excelTable[0].Columns[2].ColumnName != "规格型号")
            {
                code = "301";
                Message = "模具清单模板：表头信息不符合规范,第3列应为{规格型号}";
                return Message;
            }
            else if (excelTable[1].Columns[3].ColumnName != "*状态")
            else if (excelTable[0].Columns[3].ColumnName != "*状态")
            {
                code = "301";
                Message = "模具清单模板：表头信息不符合规范,第4列应为{*状态}";
                return Message;
            }
            else if (excelTable[1].Columns[4].ColumnName != "*仓库编码")
            else if (excelTable[0].Columns[4].ColumnName != "*仓库编码")
            {
                code = "301";
                Message = "模具清单模板：表头信息不符合规范,第5列应为{*仓库编码}";
@@ -1105,7 +1105,7 @@
                Message = "模具关联产品模板：表头信息不符合规范,第1列应为{模具编码}";
                return Message;
            }
            else if (excelTable[0].Columns[1].ColumnName != "产品编码")
            else if (excelTable[1].Columns[1].ColumnName != "产品编码")
            {
                code = "301";
                Message = "模具关联产品模板：表头信息不符合规范,第2列应为{产品编码}";
@@ -1165,82 +1165,203 @@
        }
        #endregion

        #region【Excel模板上传验证,工装保养模板】
        public static string Fourteen(string FileCode, out string code)
        #region【Excel模板上传验证,模具点检标准模板】
        public static string Thirteen_one(List<DataTable> excelTable, out string code)
        {
            string Message = "";
            code = "";
            List<DataTable> excelTable = new List<DataTable>();
            excelTable = ImportExcel.ExcelToTableList(FileCode);
            if (excelTable.Count != 2)
            {
                code = "300";
                Message = "模板不符合规范,缺失的Sheet";
                code = "301";
                Message = "导入模板不符合规范,请检查sheet数";
                return Message;

            }
            else if (excelTable[0].Columns.Count != 3)
            {
                code = "300";
                Message = "模板不符合规范,请检查列名字段数";
                code = "301";
                Message = "模具点检标准模板不符合规范,请检查列名字段数";
                return Message;
            }
            else if (excelTable[1].Columns.Count != 8)
            else if (excelTable[1].Columns.Count != 5)
            {
                code = "300";
                Message = "模板不符合规范,请检查列名字段数";
                code = "301";
                Message = "关联模具点检部位模板不符合规范,请检查列名字段数";
                return Message;
            }
            else if (excelTable[0].Columns[0].ColumnName != "序号")
            else if (excelTable[0].Columns[0].ColumnName != "*模具点检标准编号(唯一)")
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "模具点检标准模板：表头信息不符合规范,第1列应为{*模具点检标准编号(唯一)}";
                return Message;
            }
            else if (excelTable[0].Columns[1].ColumnName != "保养标准(唯一)")
            else if (excelTable[0].Columns[1].ColumnName != "*模具点检标准名称")
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "模具点检标准模板：表头信息不符合规范,第2列应为{*模具点检标准名称}";
                return Message;
            }
            else if (excelTable[0].Columns[2].ColumnName != "标准名称（唯一）")
            else if (excelTable[0].Columns[2].ColumnName != "标准描述")
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "模具点检标准模板：表头信息不符合规范,第3列应为{标准描述}";
                return Message;
            }
            else if (excelTable[1].Columns[0].ColumnName != "序号")
            else if (excelTable[1].Columns[0].ColumnName != "*模具点检标准编号")
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "关联模具点检部位模板：表头信息不符合规范,第1列应为{*模具点检标准编号}";
                return Message;
            }
            else if (excelTable[1].Columns[1].ColumnName != "保养标准")
            else if (excelTable[1].Columns[1].ColumnName != "*点检项序号")
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "关联模具点检部位模板：表头信息不符合规范,第2列应为{*点检项序号}";
                return Message;
            }
            else if (excelTable[1].Columns[2].ColumnName != "标准名称")
            else if (excelTable[1].Columns[2].ColumnName != "*模具点检项编号(唯一)")
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "关联模具点检部位模板：表头信息不符合规范,第3列应为{*模具点检项编号(唯一)}";
                return Message;
            }
            else if (excelTable[1].Columns[3].ColumnName != "SEQ(部位顺序)")
            else if (excelTable[1].Columns[3].ColumnName != "*模具点检项名称")
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "关联模具点检部位模板：表头信息不符合规范,第4列应为{*模具点检项名称}";
                return Message;
            }
            else if (excelTable[1].Columns[4].ColumnName != "部位条码（唯一）")
            else if (excelTable[1].Columns[4].ColumnName != "点检项要求")
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "关联模具点检部位模板：表头信息不符合规范,第5列应为{点检项要求}";
                return Message;
            }
            else if (excelTable[1].Columns[5].ColumnName != "部位名称")
            else
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "200";
                Message = "模板检验通过";
            }
            else if (excelTable[1].Columns[6].ColumnName != "保养要求")
            return Message;
        }
        #endregion

        #region【Excel模板上传验证,模具保养项模板】
        public static string Fourteen(List<DataTable> excelTable, out string code)
        {
            string Message = "";
            code = "";
            if (excelTable.Count != 1)
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "导入模板不符合规范,请检查sheet数";
                return Message;

            }
            else if (excelTable[1].Columns[7].ColumnName != "保养等级")
            else if (excelTable[0].Columns.Count != 3)
            {
                code = "300";
                Message = "模板不符合规范,请检查列名";
                code = "301";
                Message = "模具保养项目模板不符合规范,请检查列名字段数";
                return Message;
            }
            else if (excelTable[0].Columns[0].ColumnName != "*保养项目编号(唯一)")
            {
                code = "301";
                Message = "模具保养项目模板：表头信息不符合规范,第1列应为{*保养项目编号(唯一)}";
                return Message;
            }
            else if (excelTable[0].Columns[1].ColumnName != "*保养项目名称")
            {
                code = "301";
                Message = "模具保养项目模板：表头信息不符合规范,第2列应为{*保养项目名称}";
                return Message;
            }
            else if (excelTable[0].Columns[2].ColumnName != "要求描述")
            {
                code = "301";
                Message = "模具保养项目模板：表头信息不符合规范,第3列应为{要求描述}";
                return Message;
            }
            else
            {
                code = "200";
                Message = "模板检验通过";
            }
            return Message;
        }
        #endregion

        #region【Excel模板上传验证,模具保养标准模板】
        public static string Fourteen_one(List<DataTable> excelTable, out string code)
        {
            string Message = "";
            code = "";
            if (excelTable.Count != 2)
            {
                code = "301";
                Message = "导入模板不符合规范,请检查sheet数";
                return Message;

            }
            else if (excelTable[0].Columns.Count != 3)
            {
                code = "301";
                Message = "模具保养标准模板不符合规范,请检查列名字段数";
                return Message;
            }
            else if (excelTable[1].Columns.Count != 5)
            {
                code = "301";
                Message = "关联模具保养部位模板不符合规范,请检查列名字段数";
                return Message;
            }
            else if (excelTable[0].Columns[0].ColumnName != "*模具保养标准编号(唯一)")
            {
                code = "301";
                Message = "模具保养标准模板：表头信息不符合规范,第1列应为{*模具保养标准编号(唯一)}";
                return Message;
            }
            else if (excelTable[0].Columns[1].ColumnName != "*模具保养标准名称")
            {
                code = "301";
                Message = "模具保养标准模板：表头信息不符合规范,第2列应为{*模具保养标准名称}";
                return Message;
            }
            else if (excelTable[0].Columns[2].ColumnName != "标准描述")
            {
                code = "301";
                Message = "模具保养标准模板：表头信息不符合规范,第3列应为{标准描述}";
                return Message;
            }
            else if (excelTable[1].Columns[0].ColumnName != "*模具保养标准编号")
            {
                code = "301";
                Message = "关联模具保养部位模板：表头信息不符合规范,第1列应为{*模具保养标准编号}";
                return Message;
            }
            else if (excelTable[1].Columns[1].ColumnName != "*保养项序号")
            {
                code = "301";
                Message = "关联模具保养部位模板：表头信息不符合规范,第2列应为{*保养项序号}";
                return Message;
            }
            else if (excelTable[1].Columns[2].ColumnName != "*模具保养项编号(唯一)")
            {
                code = "301";
                Message = "关联模具保养部位模板：表头信息不符合规范,第3列应为{*模具保养项编号(唯一)}";
                return Message;
            }
            else if (excelTable[1].Columns[3].ColumnName != "*模具保养项名称")
            {
                code = "301";
                Message = "关联模具保养部位模板：表头信息不符合规范,第4列应为{*模具保养项名称}";
                return Message;
            }
            else if (excelTable[1].Columns[4].ColumnName != "保养项要求")
            {
                code = "301";
                Message = "关联模具保养部位模板：表头信息不符合规范,第5列应为{保养项要求}";
                return Message;
            }
            else
            {
@@ -3430,7 +3551,7 @@
                        ExcelErro erro = new ExcelErro();
                        erro.RoeNumber = "/";
                        erro.ErrorField = "{*点检项目名称}";
                        erro.ErrorCont = "模具点检项目表:{*点检项目名称}字段" + excelTable[1].Rows[k][1].ToString().Trim() + "已存在";
                        erro.ErrorCont = "模具点检项目表:{*点检项目名称}字段" + excelTable[0].Rows[k][1].ToString().Trim() + "已存在";
                        list.Add(erro);
                    }
                }
@@ -3456,16 +3577,282 @@
        }
        #endregion

        #region【Excel上传数据验证,工装保养】
        public static List<ExcelErro> FourteenData(string FileCode, out string StuCode, out string message, out int count)
        #region【Excel上传数据验证,模具点检标准】
        public static List<ExcelErro> Thirteen_oneData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
        {
            message = "";
            StuCode = "";
            count = 0;
            string sql = "";
            var dynamicParams = new DynamicParameters();
            DataTable dt;
            List<ExcelErro> list = new List<ExcelErro>();
            list = ImportExcel.InportExcelToTableListErro(excelTable);    //验证Excel数据必填字段是否为空、唯一字段是否重复
            //模具点检标准表是否已存在点检标准
            for (int j = 0; j < excelTable[0].Rows.Count; j++)
            {
                if (excelTable[0].Rows[j][0].ToString().Trim() != null && excelTable[0].Rows[j][0].ToString().Trim() != "")
                {
                    sql = @"select *  from TMouldchk_Main where code=@code";
                    dynamicParams.Add("@code", excelTable[0].Rows[j][0].ToString().Trim());
                    dt = DapperHelper.selectdata(sql, dynamicParams);
                    if (dt.Rows.Count > 0)
                    {
                        ExcelErro erro = new ExcelErro();
                        erro.RoeNumber = "/";
                        erro.ErrorField = "{*模具点检标准编号(唯一)}";
                        erro.ErrorCont = "模具点检标准表:{*模具点检标准编号(唯一)}字段" + excelTable[0].Rows[j][0].ToString().Trim() + "在数据表中已存在";
                        list.Add(erro);
                    }
                    //通过模具点检标准页签模板中的标准编码查询模具点检项页签模板中对应的数据信息
                    var var_dtTable = excelTable[1].AsEnumerable().Where<DataRow>(W => W["*模具点检标准编号"].ToString() == excelTable[0].Rows[j][0].ToString().Trim());
                    DataTable ds = var_dtTable.Any() ? var_dtTable.CopyToDataTable() : excelTable[1].Clone();
                    if (ds.Rows.Count > 0)
                    {
                        //判断点检标准查询点检项数据是否有重复
                        DataTable distinct1 = ds.DefaultView.ToTable(true, "*模具点检项编号(唯一)");
                        if (distinct1.Rows.Count != ds.Rows.Count)
                        {
                            ExcelErro erro = new ExcelErro();
                            erro.RoeNumber = "/";
                            erro.ErrorField = "{*模具点检项编号(唯一)}";
                            erro.ErrorCont = "模具点检项页签模板:{*模具点检标准编号}:" + excelTable[1].Rows[j][0].ToString().Trim() + " å¯¹åº”{*模具点检项编号(唯一)}有重复";
                            list.Add(erro);
                        }
                    }
                    else
                    {
                        ExcelErro erro = new ExcelErro();
                        erro.RoeNumber = "/";
                        erro.ErrorField = "{*模具点检项编号(唯一)}";
                        erro.ErrorCont = "模具点检项页签模板:{*模具点检标准编号}:" + excelTable[1].Rows[j][0].ToString().Trim() + " åœ¨æ¨¡å…·ç‚¹æ£€æ ‡å‡†é¡µç­¾æ¨¡æ¿ä¸­ä¸å­˜åœ¨";
                        list.Add(erro);
                    }
                }
            }
            //当前Excel数据中点检项页签中,模具点检项编号(唯一)在模具点检部位表中是否存在
            for (int k = 0; k < excelTable[1].Rows.Count; k++)
            {
                if (excelTable[1].Rows[k][2].ToString().Trim() != null && excelTable[1].Rows[k][2].ToString().Trim() != "")
                {
                    sql = @"select *  from TMouldchk_Item where code=@code";
                    dynamicParams.Add("@code", excelTable[1].Rows[k][2].ToString().Trim());
                    dt = DapperHelper.selectdata(sql, dynamicParams);
                    if (dt.Rows.Count < 0)
                    {
                        ExcelErro erro = new ExcelErro();
                        erro.RoeNumber = "/";
                        erro.ErrorField = "{*模具点检项编号(唯一)}";
                        erro.ErrorCont = "模具点检部位表:{*模具点检项编号(唯一)}字段" + excelTable[1].Rows[k][2].ToString().Trim() + "在数据表中不存在";
                        list.Add(erro);
                    }
                }
            }
            //判断子表外键不存在于主表主键中的数据
            var dt3 = from r in excelTable[1].AsEnumerable()
                      where !(
                          from rr in excelTable[0].AsEnumerable()
                          select rr.Field<string>("*模具点检标准编号(唯一)")
                      ).Contains(r.Field<string>("*模具点检标准编号"))
                      select r;
            List<DataRow> listRow = dt3.ToList();
            if (listRow.Count > 0)
            {
                ExcelErro erro = new ExcelErro();
                erro.RoeNumber = "/";
                erro.ErrorField = "{*模具点检标准编号}";
                erro.ErrorCont = "模具点检项页签模板:{*模具点检标准编号}字段中有值在模具点检标准页签模板:{*模具点检标准编号(唯一)}中不存在";
                list.Add(erro);
            }
            if (list.Count > 0)
            {
                int index = 0;
                foreach (ExcelErro item in list)
                {
                    index++;
                    item.Seq = index.ToString();
                }
                StuCode = "301";
                message = "数据验证失败";
            }
            else
            {
                StuCode = "200";
                message = "数据验证成功";
                count = excelTable[0].Rows.Count + excelTable[1].Rows.Count;
            }
            return list;
        }
        #endregion

        #region【Excel上传数据验证,模具保养项目】
        public static List<ExcelErro> FourteenData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
        {
            message = "";
            StuCode = "";
            count = 0;
            string sql = "";
            var dynamicParams = new DynamicParameters();
            DataTable dt;
            List<ExcelErro> list = new List<ExcelErro>();
            list = ImportExcel.InportExcelToTableListErro(excelTable);    //验证Excel数据必填字段是否为空、唯一字段是否重复
            //模具保养项目表
            for (int k = 0; k < excelTable[0].Rows.Count; k++)
            {
                if (excelTable[0].Rows[k][0].ToString().Trim() != null && excelTable[0].Rows[k][0].ToString().Trim() != "")
                {
                    sql = @"select *  from TMouldmai_Item where code=@code";
                    dynamicParams.Add("@code", excelTable[0].Rows[k][0].ToString().Trim());
                    dt = DapperHelper.selectdata(sql, dynamicParams);
                    if (dt.Rows.Count > 0)
                    {
                        ExcelErro erro = new ExcelErro();
                        erro.RoeNumber = "/";
                        erro.ErrorField = "{*保养项目编号(唯一)}";
                        erro.ErrorCont = "模具保养项目:{*保养项目编号(唯一)}字段" + excelTable[0].Rows[k][0].ToString().Trim() + "已存在";
                        list.Add(erro);
                    }
                }
                if (excelTable[0].Rows[k][1].ToString().Trim() != null && excelTable[0].Rows[k][1].ToString().Trim() != "")
                {
                    sql = @"select *  from TMouldmai_Item where name=@name";
                    dynamicParams.Add("@name", excelTable[0].Rows[k][1].ToString().Trim());
                    dt = DapperHelper.selectdata(sql, dynamicParams);
                    if (dt.Rows.Count > 0)
                    {
                        ExcelErro erro = new ExcelErro();
                        erro.RoeNumber = "/";
                        erro.ErrorField = "{*保养项目名称}";
                        erro.ErrorCont = "模具保养项目表:{*保养项目名称}字段" + excelTable[0].Rows[k][1].ToString().Trim() + "已存在";
                        list.Add(erro);
                    }
                }
            }
            if (list.Count > 0)
            {
                int index = 0;
                foreach (ExcelErro item in list)
                {
                    index++;
                    item.Seq = index.ToString();
                }
                StuCode = "301";
                message = "数据验证失败";
            }
            else
            {
                StuCode = "200";
                message = "数据验证成功";
                count = excelTable[0].Rows.Count;
            }
            return list;
        }
        #endregion

        #region【Excel上传数据验证,模具保养标准】
        public static List<ExcelErro> FourteenData_one(List<DataTable> excelTable, out string StuCode, out string message, out int count)
        {
            message = "";
            StuCode = "";
            count = 0;
            string sql = "";
            var dynamicParams = new DynamicParameters();
            DataTable dt;
            List<ExcelErro> list = new List<ExcelErro>();
            list = ImportExcel.InportExcelToTableListErro(excelTable);    //验证Excel数据必填字段是否为空、唯一字段是否重复
            //模具保养标准表是否已存在保养标准
            for (int j = 0; j < excelTable[0].Rows.Count; j++)
            {
                if (excelTable[0].Rows[j][0].ToString().Trim() != null && excelTable[0].Rows[j][0].ToString().Trim() != "")
                {
                    sql = @"select *  from TMouldmai_Main where code=@code";
                    dynamicParams.Add("@code", excelTable[0].Rows[j][0].ToString().Trim());
                    dt = DapperHelper.selectdata(sql, dynamicParams);
                    if (dt.Rows.Count > 0)
                    {
                        ExcelErro erro = new ExcelErro();
                        erro.RoeNumber = "/";
                        erro.ErrorField = "{*模具保养标准编号(唯一)}";
                        erro.ErrorCont = "模具保养标准表:{*模具保养标准编号(唯一)}字段" + excelTable[0].Rows[j][0].ToString().Trim() + "在数据表中已存在";
                        list.Add(erro);
                    }
                    //通过模具保养标准页签模板中的标准编码查询模具保养项页签模板中对应的数据信息
                    var var_dtTable = excelTable[1].AsEnumerable().Where<DataRow>(W => W["*模具保养标准编号"].ToString() == excelTable[0].Rows[j][0].ToString().Trim());
                    DataTable ds = var_dtTable.Any() ? var_dtTable.CopyToDataTable() : excelTable[1].Clone();
                    if (ds.Rows.Count > 0)
                    {
                        //判断保养标准查询保养项数据是否有重复
                        DataTable distinct1 = ds.DefaultView.ToTable(true, "*模具保养项编号(唯一)");
                        if (distinct1.Rows.Count != ds.Rows.Count)
                        {
                            ExcelErro erro = new ExcelErro();
                            erro.RoeNumber = "/";
                            erro.ErrorField = "{*模具保养项编号(唯一)}";
                            erro.ErrorCont = "模具保养项页签模板:{*模具保养标准编号}:" + excelTable[1].Rows[j][0].ToString().Trim() + " å¯¹åº”{*模具保养项编号(唯一)}有重复";
                            list.Add(erro);
                        }
                    }
                    else
                    {
                        ExcelErro erro = new ExcelErro();
                        erro.RoeNumber = "/";
                        erro.ErrorField = "{*模具保养项编号(唯一)}";
                        erro.ErrorCont = "模具保养项页签模板:{*模具保养标准编号}:" + excelTable[1].Rows[j][0].ToString().Trim() + " åœ¨æ¨¡å…·ä¿å…»æ ‡å‡†é¡µç­¾æ¨¡æ¿ä¸­ä¸å­˜åœ¨";
                        list.Add(erro);
                    }
                }
            }
            //当前Excel数据中保养项页签中,模具保养项编号(唯一)在模具保养部位表中是否存在
            for (int k = 0; k < excelTable[1].Rows.Count; k++)
            {
                if (excelTable[1].Rows[k][2].ToString().Trim() != null && excelTable[1].Rows[k][2].ToString().Trim() != "")
                {
                    sql = @"select *  from TMouldmai_Item where code=@code";
                    dynamicParams.Add("@code", excelTable[1].Rows[k][2].ToString().Trim());
                    dt = DapperHelper.selectdata(sql, dynamicParams);
                    if (dt.Rows.Count < 0)
                    {
                        ExcelErro erro = new ExcelErro();
                        erro.RoeNumber = "/";
                        erro.ErrorField = "{*模具保养项编号(唯一)}";
                        erro.ErrorCont = "模具保养部位表:{*模具保养项编号(唯一)}字段" + excelTable[1].Rows[k][2].ToString().Trim() + "在数据表中不存在";
                        list.Add(erro);
                    }
                }
            }
            //判断子表外键不存在于主表主键中的数据
            var dt3 = from r in excelTable[1].AsEnumerable()
                      where !(
                          from rr in excelTable[0].AsEnumerable()
                          select rr.Field<string>("*模具保养标准编号(唯一)")
                      ).Contains(r.Field<string>("*模具保养标准编号"))
                      select r;
            List<DataRow> listRow = dt3.ToList();
            if (listRow.Count > 0)
            {
                ExcelErro erro = new ExcelErro();
                erro.RoeNumber = "/";
                erro.ErrorField = "{*模具保养标准编号}";
                erro.ErrorCont = "模具保养项页签模板:{*模具保养标准编号}字段中有值在模具保养标准页签模板:{*模具保养标准编号(唯一)}中不存在";
                list.Add(erro);
            }
            if (list.Count > 0)
            {
                int index = 0;
                foreach (ExcelErro item in list)
                {
                    index++;
                    item.Seq = index.ToString();
                }
                StuCode = "301";
                message = "数据验证失败";
            }
            else
            {
                StuCode = "200";
                message = "数据验证成功";
                count = excelTable[0].Rows.Count + excelTable[1].Rows.Count;
            }
            return list;
        }
        #endregion
@@ -5114,14 +5501,186 @@
        }
        #endregion

        #region【Excel数据上传,工装保养】
        public static string FourteenSubmit(string FileCode, string User, out string StuCode)
        #region【Excel数据上传,模具点检标准】
        public static string Thirteen_oneSubmit(List<DataTable> excelTable, User us, out string StuCode)
        {
            string message = "";
            StuCode = "";
            string sql = "";
            List<object> list = new List<object>();
            var dynamicParams = new DynamicParameters();
            try
            {
                list.Clear();
                //导入模具点检标准主表
                for (int k = 0; k < excelTable[0].Rows.Count; k++)
                {
                    sql = @"insert into TMouldchk_Main(code,name,description,lm_user,lm_date) 
                            values(@code,@name,@description,@Operator,@CreateDate)";
                    list.Add(new
                    {
                        str = sql,
                        parm = new
                        {
                            code = excelTable[0].Rows[k][0].ToString().Trim(),
                            name = excelTable[0].Rows[k][1].ToString().Trim(),
                            description = excelTable[0].Rows[k][2].ToString().Trim(),
                            CreateDate = DateTime.Now.ToString(),
                            Operator = us.usercode
                        }
                    });
                }
                //导入模具点检标准关联点检项子表
                for (int i = 0; i < excelTable[1].Rows.Count; i++)
                {
                    sql = @"insert into TMouldchk_Deta(seq,code,name,mouldchk_main_code,chkdesc,lm_user,lm_date) 
                            values(@seq,@code,@name,@mouldchk_main_code,@description,@Operator,@CreateDate)";
                    list.Add(new
                    {
                        str = sql,
                        parm = new
                        {
                            seq = excelTable[1].Rows[i][1].ToString().Trim(),
                            code = excelTable[1].Rows[i][2].ToString().Trim(),
                            name = excelTable[1].Rows[i][3].ToString().Trim(),
                            mouldchk_main_code = excelTable[1].Rows[i][0].ToString().Trim(),
                            description = excelTable[1].Rows[i][4].ToString().Trim(),
                            Operator = us.usercode,
                            CreateDate = DateTime.Now.ToString()
                        }
                    });
                }
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    StuCode = "200";
                    message = "导入成功！";
                }
                else
                {
                    StuCode = "300";
                    message = "导入失败！";
                }
            }
            catch (Exception e)
            {
                StuCode = "300";
                message = e.Message;
            }
            return message;
        }
        #endregion

        #region【Excel数据上传,模具保养项目】
        public static string FourteenSubmit(List<DataTable> excelTable, User us, out string StuCode)
        {
            string message = "";
            StuCode = "";
            string sql = "";
            List<object> list = new List<object>();
            var dynamicParams = new DynamicParameters();
            try
            {
                list.Clear();
                //导入模具保养项目表
                for (int i = 0; i < excelTable[0].Rows.Count; i++)
                {
                    sql = @"insert into TMouldmai_Item(code,name,description,lm_user,lm_date) 
                            values(@code,@name,@description,@lm_user,@lm_date)";
                    list.Add(new
                    {
                        str = sql,
                        parm = new
                        {
                            code = excelTable[0].Rows[i][0].ToString().Trim(),
                            name = excelTable[0].Rows[i][1].ToString().Trim(),
                            description = excelTable[0].Rows[i][2].ToString().Trim(),
                            lm_user = us.usercode,
                            lm_date = DateTime.Now.ToString()
                        }
                    });
                }
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    StuCode = "200";
                    message = "导入成功！";
                }
                else
                {
                    StuCode = "300";
                    message = "导入失败！";
                }
            }
            catch (Exception e)
            {
                StuCode = "300";
                message = e.Message;
            }
            return message;
        }
        #endregion

        #region【Excel数据上传,模具保养标准】
        public static string Fourteen_oneSubmit(List<DataTable> excelTable, User us, out string StuCode)
        {
            string message = "";
            StuCode = "";
            string sql = "";
            List<object> list = new List<object>();
            var dynamicParams = new DynamicParameters();
            try
            {
                list.Clear();
                //导入模具保养标准主表
                for (int k = 0; k < excelTable[0].Rows.Count; k++)
                {
                    sql = @"insert into TMouldmai_Main(code,name,description,lm_user,lm_date) 
                            values(@code,@name,@description,@Operator,@CreateDate)";
                    list.Add(new
                    {
                        str = sql,
                        parm = new
                        {
                            code = excelTable[0].Rows[k][0].ToString().Trim(),
                            name = excelTable[0].Rows[k][1].ToString().Trim(),
                            description = excelTable[0].Rows[k][2].ToString().Trim(),
                            CreateDate = DateTime.Now.ToString(),
                            Operator = us.usercode
                        }
                    });
                }
                //导入模具保养标准关联保养项子表
                for (int i = 0; i < excelTable[1].Rows.Count; i++)
                {
                    sql = @"insert into TMouldmai_Deta(seq,code,name,mouldmai_main_code,chkdesc,lm_user,lm_date) 
                            values(@seq,@code,@name,@mouldmai_main_code,@description,@Operator,@CreateDate)";
                    list.Add(new
                    {
                        str = sql,
                        parm = new
                        {
                            seq = excelTable[1].Rows[i][1].ToString().Trim(),
                            code = excelTable[1].Rows[i][2].ToString().Trim(),
                            name = excelTable[1].Rows[i][3].ToString().Trim(),
                            mouldmai_main_code = excelTable[1].Rows[i][0].ToString().Trim(),
                            description = excelTable[1].Rows[i][4].ToString().Trim(),
                            Operator = us.usercode,
                            CreateDate = DateTime.Now.ToString()
                        }
                    });
                }
                bool aa = DapperHelper.DoTransaction(list);
                if (aa)
                {
                    StuCode = "200";
                    message = "导入成功！";
                }
                else
                {
                    StuCode = "300";
                    message = "导入失败！";
                }
            }
            catch (Exception e)
            {

 VueWebCoreApi/wwwroot/Excel/Ä£¾ß±£Ñø±ê×¼.xls

Binary files differ

 VueWebCoreApi/wwwroot/Excel/Ä£¾ß±£ÑøÏîÄ¿.xls

Binary files differ

 VueWebCoreApi/wwwroot/Excel/Ä£¾ßµã¼ì±ê×¼.xls

Binary files differ