JLApi.git - Gitblit

			@@ -21,95 +21,51 @@
			code = "";
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);


			return Message;
			}
			#endregion

			#region【Excel模板上传验证,岗位管理模板】
			public static string One(string FileCode, out string code)
			public static string One(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			if (excelTable.Count != 4)
			if (excelTable.Count != 1)
			{
			code = "300";
			code = "301";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable[0].Columns.Count != 4)
			{
			code = "300";
			Message = "角色类型模板不符合规范,请检查列名字段数";
			code = "301";
			Message = "岗位清单模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[1].Columns.Count != 6)
			else if (excelTable[0].Columns[0].ColumnName != "*岗位编号(唯一)")
			{
			code = "300";
			Message = "模板角色清单不符合规范,请检查列名字段数";
			code = "301";
			Message = "岗位清单模板：表头信息不符合规范,第1列应为{*岗位编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns[1].ColumnName != "*岗位名称")
			{
			code = "300";
			Message = "角色类型模板：表头信息不符合规范,第1列应为{序号}";
			code = "301";
			Message = "岗位清单模板：表头信息不符合规范,第2列应为{*岗位名称}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "组织编码")
			else if (excelTable[0].Columns[2].ColumnName != "*状态")
			{
			code = "300";
			Message = "角色类型模板：表头信息不符合规范,第1列应为{组织编码}";
			code = "301";
			Message = "岗位清单模板：表头信息不符合规范,第3列应为{*状态}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "角色类型编号(唯一)")
			else if (excelTable[0].Columns[3].ColumnName != "描述")
			{
			code = "300";
			Message = "角色类型模板：表头信息不符合规范,第2列应为{角色类型编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "角色类型名称")
			{
			code = "300";
			Message = "角色类型模板：表头信息不符合规范,第3列应为{角色类型名称}";
			return Message;
			}
			else if (excelTable[1].Columns[0].ColumnName != "序号")
			{
			code = "300";
			Message = "角色清单模板：表头信息不符合规范,第1列应为{序号}";
			return Message;
			}
			else if (excelTable[1].Columns[1].ColumnName != "组织编码")
			{
			code = "300";
			Message = "角色清单模板：表头信息不符合规范,第1列应为{组织编码}";
			return Message;
			}
			else if (excelTable[1].Columns[2].ColumnName != "角色编号(唯一)")
			{
			code = "300";
			Message = "角色清单模板：表头信息不符合规范,第2列应为{角色编号(唯一)}";
			return Message;
			}
			else if (excelTable[1].Columns[3].ColumnName != "角色姓名")
			{
			code = "300";
			Message = "角色清单模板：表头信息不符合规范,第3列应为{角色姓名}";
			return Message;
			}
			else if (excelTable[1].Columns[4].ColumnName != "角色类型编码")
			{
			code = "300";
			Message = "角色清单模板：表头信息不符合规范,第4列应为{角色类型编码}";
			return Message;
			}
			else if (excelTable[1].Columns[5].ColumnName != "角色描述")
			{
			code = "300";
			Message = "角色清单模板：表头信息不符合规范,第5列应为{角色描述}";
			code = "301";
			Message = "岗位清单模板：表头信息不符合规范,第4列应为{描述}";
			return Message;
			}
			else
			@@ -122,11 +78,52 @@
			#endregion

			#region【Excel模板上传验证,班组管理模板】
			public static string Two(string FileCode, out string code)
			public static string Two(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";

			if (excelTable.Count != 1)
			{
			code = "301";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable[0].Columns.Count != 4)
			{
			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[0].Columns[3].ColumnName != "描述")
			{
			code = "301";
			Message = "班组清单模板：表头信息不符合规范,第4列应为{描述}";
			return Message;
			}
			else
			{
			code = "200";
			Message = "模板检验通过";
			}
			return Message;
			}
			#endregion
			@@ -219,65 +216,45 @@
			#endregion

			#region【Excel模板上传验证,角色管单模板】
			public static string Four(string FileCode, out string code)
			public static string Four(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			if (excelTable.Count != 2)
			if (excelTable.Count != 1)
			{
			code = "300";
			code = "301";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable[0].Columns.Count != 7)
			else if (excelTable[0].Columns.Count != 4)
			{
			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 = "往来单位模板不符合规范：表头信息不符合规范,第1列应为{序号}";
			code = "301";
			Message = "角色清单模板：表头信息不符合规范,第1列应为{*角色编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "往来单位编号(唯一)")
			else if (excelTable[0].Columns[1].ColumnName != "*角色名称")
			{
			code = "300";
			Message = "往来单位模板不符合规范：表头信息不符合规范,第2列应为{往来单位编号(唯一)}";
			code = "301";
			Message = "角色清单模板：表头信息不符合规范,第2列应为{*角色名称}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "往来单位名称")
			else if (excelTable[0].Columns[2].ColumnName != "*状态")
			{
			code = "300";
			Message = "往来单位模板不符合规范：表头信息不符合规范,第3列应为{往来单位名称}";
			code = "301";
			Message = "角色清单模板：表头信息不符合规范,第3列应为{*状态}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "往来单位属性")
			else if (excelTable[0].Columns[3].ColumnName != "描述")
			{
			code = "300";
			Message = "往来单位模板不符合规范：表头信息不符合规范,第4列应为{往来单位属性}";
			return Message;
			}
			else if (excelTable[0].Columns[4].ColumnName != "联系人")
			{
			code = "300";
			Message = "往来单位模板不符合规范：表头信息不符合规范,第5列应为{联系人}";
			return Message;
			}
			else if (excelTable[0].Columns[5].ColumnName != "联系方式")
			{
			code = "300";
			Message = "往来单位模板不符合规范：表头信息不符合规范,第6列应为{联系方式}";
			return Message;
			}
			else if (excelTable[0].Columns[6].ColumnName != "地址")
			{
			code = "300";
			Message = "往来单位模板不符合规范：表头信息不符合规范,第7列应为{地址}";
			code = "301";
			Message = "角色清单模板：表头信息不符合规范,第4列应为{描述}";
			return Message;
			}
			else
			@@ -290,93 +267,144 @@
			#endregion

			#region【Excel模板上传验证,往来单位模板】
			public static string Five(string FileCode, out string code)
			public static string Five(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 != 7)
			{
			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 if (excelTable[1].Columns[5].ColumnName != "联系方式")
			{
			code = "301";
			Message = "往来单位模板：表头信息不符合规范,第6列应为{联系人}";
			return Message;
			}
			else if (excelTable[1].Columns[6].ColumnName != "地址")
			{
			code = "301";
			Message = "往来单位模板：表头信息不符合规范,第7列应为{地址}";
			return Message;
			}
			else
			{
			code = "200";
			Message = "模板检验通过";
			}
			return Message;
			}
			#endregion

			#region【Excel模板上传验证,仓库设置模板】
			public static string Six(string FileCode, out string code)
			public static string Six(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			if (excelTable.Count != 4)
			if (excelTable.Count != 1)
			{
			code = "300";
			code = "301";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable[0].Columns.Count != 4)
			else if (excelTable[0].Columns.Count != 5)
			{
			code = "300";
			Message = "仓库清单模板不符合规范,请检查列名字段数";
			code = "301";
			Message = "仓库设置模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[1].Columns.Count != 5)
			else if (excelTable[0].Columns[0].ColumnName != "*仓库编号(唯一)")
			{
			code = "300";
			Message = "库位清单模板不符合规范,请检查列名字段数";
			code = "301";
			Message = "仓库设置模板：表头信息不符合规范,第1列应为{*仓库编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns[1].ColumnName != "*仓库名称")
			{
			code = "300";
			Message = "仓库清单模板：表头信息不符合规范,第1列应为{序号}";
			code = "301";
			Message = "仓库设置模板：表头信息不符合规范,第2列应为{*仓库名称}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "仓库编号(唯一)")
			else if (excelTable[0].Columns[2].ColumnName != "*状态")
			{
			code = "300";
			Message = "仓库清单模板：表头信息不符合规范,第2列应为{仓库编号(唯一)}";
			code = "301";
			Message = "仓库设置模板：表头信息不符合规范,第3列应为{*状态}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "仓库名称")
			else if (excelTable[0].Columns[3].ColumnName != "*库位管理")
			{
			code = "300";
			Message = "仓库清单模板：表头信息不符合规范,第3列应为{仓库名称}";
			code = "301";
			Message = "仓库设置模板：表头信息不符合规范,第4列应为{*库位管理}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "仓库描述")
			else if (excelTable[0].Columns[4].ColumnName != "描述")
			{
			code = "300";
			Message = "仓库清单模板：表头信息不符合规范,第4列应为{仓库描述}";
			return Message;
			}
			else if (excelTable[1].Columns[0].ColumnName != "序号")
			{
			code = "300";
			Message = "库位清单模板：表头信息不符合规范,第1列应为{序号}";
			return Message;
			}
			else if (excelTable[1].Columns[1].ColumnName != "库位编号(唯一)")
			{
			code = "300";
			Message = "库位清单模板：表头信息不符合规范,第2列应为{库位编号(唯一)}";
			return Message;
			}
			else if (excelTable[1].Columns[2].ColumnName != "库位姓名")
			{
			code = "300";
			Message = "库位清单模板：表头信息不符合规范,第3列应为{库位姓名}";
			return Message;
			}
			else if (excelTable[1].Columns[3].ColumnName != "所属仓库编码")
			{
			code = "300";
			Message = "库位清单模板：表头信息不符合规范,第4列应为{所属仓库编码}";
			return Message;
			}
			else if (excelTable[1].Columns[4].ColumnName != "库位描述")
			{
			code = "300";
			Message = "库位清单模板：表头信息不符合规范,第5列应为{库位描述}";
			code = "301";
			Message = "仓库设置模板：表头信息不符合规范,第5列应为{描述}";
			return Message;
			}
			else
			@@ -389,41 +417,58 @@
			#endregion

			#region【Excel模板上传验证,库位设置模板】
			public static string Seven(string FileCode, out string code)
			public static string Seven(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			if (excelTable.Columns.Count != 5)
			if (excelTable.Count != 1)
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable.Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns.Count != 6)
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "库位设置模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable.Columns[1].ColumnName != "容器编码(唯一)")
			else if (excelTable[0].Columns[0].ColumnName != "*库位编号(唯一)")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "库位设置模板：表头信息不符合规范,第1列应为{*库位编号(唯一)}";
			return Message;
			}
			else if (excelTable.Columns[2].ColumnName != "容器名称（唯一）")
			else if (excelTable[0].Columns[1].ColumnName != "*库位名称")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "库位设置模板：表头信息不符合规范,第2列应为{*库位名称}";
			return Message;
			}
			else if (excelTable.Columns[3].ColumnName != "容器自重（KG）")
			else if (excelTable[0].Columns[2].ColumnName != "*所属仓库编码")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "库位设置模板：表头信息不符合规范,第3列应为{*所属仓库编码}";
			return Message;
			}
			else if (excelTable.Columns[4].ColumnName != "容器类型")
			else if (excelTable[0].Columns[3].ColumnName != "上级库位编码")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "库位设置模板：表头信息不符合规范,第4列应为{上级库位编码}";
			return Message;
			}
			else if (excelTable[0].Columns[4].ColumnName != "*状态")
			{
			code = "301";
			Message = "库位设置模板：表头信息不符合规范,第5列应为{*状态}";
			return Message;
			}
			else if (excelTable[0].Columns[5].ColumnName != "描述")
			{
			code = "301";
			Message = "库位设置模板：表头信息不符合规范,第6列应为{描述}";
			return Message;
			}
			else
			{
			@@ -435,71 +480,124 @@
			#endregion

			#region【Excel模板上传验证,存货档案模板】
			public static string Eight(string FileCode, out string code)
			public static string Eight(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			if (excelTable.Columns.Count != 11)
			if (excelTable.Count != 2)
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable.Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns.Count != 3)
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货分类模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable.Columns[1].ColumnName != "物料编码(唯一)")
			else if (excelTable[1].Columns.Count != 13)
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货档案模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable.Columns[2].ColumnName != "物料名称")
			else if (excelTable[0].Columns[0].ColumnName != "*存货分类编号(唯一)")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货分类型模板：表头信息不符合规范,第1列应为{*存货分类编号(唯一)}";
			return Message;
			}
			else if (excelTable.Columns[3].ColumnName != "物料规格")
			else if (excelTable[0].Columns[1].ColumnName != "*存货分类名称")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货分类型模板：表头信息不符合规范,第2列应为{*存货分类名称}";
			return Message;
			}
			else if (excelTable.Columns[4].ColumnName != "主单位")
			else if (excelTable[0].Columns[2].ColumnName != "上级编码")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货分类型模板：表头信息不符合规范,第3列应为{上级编码}";
			return Message;
			}
			else if (excelTable.Columns[5].ColumnName != "辅单位")
			else if (excelTable[1].Columns[0].ColumnName != "*存货编号(唯一)")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第1列应为{*存货编号(唯一)}";
			return Message;
			}
			else if (excelTable.Columns[6].ColumnName != "辅/主")
			else if (excelTable[1].Columns[1].ColumnName != "*存货名称")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第2列应为{*存货名称}";
			return Message;
			}
			else if (excelTable.Columns[7].ColumnName != "物料类别")
			else if (excelTable[1].Columns[2].ColumnName != "规格型号")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第3列应为{规格型号}";
			return Message;
			}
			else if (excelTable.Columns[8].ColumnName != "仓库名称")
			else if (excelTable[1].Columns[3].ColumnName != "*存货分类编码")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第4列应为{*存货分类编码}";
			return Message;
			}
			else if (excelTable.Columns[9].ColumnName != "库存下限")
			else if (excelTable[1].Columns[4].ColumnName != "*状态")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第5列应为{*状态}";
			return Message;
			}
			else if (excelTable.Columns[10].ColumnName != "库存上限")
			else if (excelTable[1].Columns[5].ColumnName != "*计量方式")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第6列应为{*计量方式}";
			return Message;
			}
			else if (excelTable[1].Columns[6].ColumnName != "*计量单位/组名称")
			{
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第7列应为{*计量单位/组名称}";
			return Message;
			}
			else if (excelTable[1].Columns[7].ColumnName != "所属仓库编码")
			{
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第8列应为{所属仓库编码}";
			return Message;
			}
			else if (excelTable[1].Columns[8].ColumnName != "是否外购")
			{
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第9列应为{是否外购}";
			return Message;
			}
			else if (excelTable[1].Columns[9].ColumnName != "是否销售")
			{
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第10列应为{是否销售}";
			return Message;
			}
			else if (excelTable[1].Columns[10].ColumnName != "是否自制")
			{
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第11列应为{是否自制}";
			return Message;
			}
			else if (excelTable[1].Columns[11].ColumnName != "是否生产消耗")
			{
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第12列应为{是否生产消耗}";
			return Message;
			}
			else if (excelTable[1].Columns[12].ColumnName != "是否委外")
			{
			code = "301";
			Message = "存货档案模板：表头信息不符合规范,第13列应为{是否委外}";
			return Message;
			}
			else
			{
			@@ -511,56 +609,76 @@
			#endregion

			#region【Excel模板上传验证,设备清单模板】
			public static string Nine(string FileCode, out string code)
			public static string Nine(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 != 7)
			else if (excelTable[0].Columns.Count != 3)
			{
			code = "300";
			Message = "设备清单模板(设备清单)不符合规范,请检查列名字段数";
			code = "301";
			Message = "设备类型模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			else if (excelTable[1].Columns.Count != 5)
			{
			code = "300";
			Message = "设备清单模板(设备清单)：表头信息不符合规范,第1列应为{序号}";
			code = "301";
			Message = "设备清单模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "设备编号(唯一)")
			else if (excelTable[0].Columns[0].ColumnName != "*设备类型编号(唯一)")
			{
			code = "300";
			Message = "设备清单模板(设备清单)：表头信息不符合规范,第1列应为{设备编号(唯一)}";
			code = "301";
			Message = "设备类型模板：表头信息不符合规范,第1列应为{*设备类型编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "设备名称")
			else if (excelTable[0].Columns[1].ColumnName != "*设备类型名称")
			{
			code = "300";
			Message = "设备清单模板(设备清单)：表头信息不符合规范,第1列应为{设备名称}";
			code = "301";
			Message = "设备类型模板：表头信息不符合规范,第2列应为{*设备类型名称}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "投入日期")
			else if (excelTable[0].Columns[2].ColumnName != "描述")
			{
			code = "300";
			Message = "设备清单模板(设备清单)：表头信息不符合规范,第1列应为{投入日期}";
			code = "301";
			Message = "设备类型模板：表头信息不符合规范,第3列应为{描述}";
			return Message;
			}
			else if (excelTable[0].Columns[4].ColumnName != "车间编码")
			else if (excelTable[1].Columns[0].ColumnName != "*设备编号(唯一)")
			{
			code = "300";
			Message = "设备清单模板(设备清单)：表头信息不符合规范,第1列应为{车间编码}";
			code = "301";
			Message = "设备清单模板：表头信息不符合规范,第1列应为{*设备编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[5].ColumnName != "使用状态")
			else if (excelTable[1].Columns[1].ColumnName != "*设备名称")
			{
			code = "300";
			Message = "设备清单模板(设备清单)：表头信息不符合规范,第1列应为{使用状态}";
			code = "301";
			Message = "设备清单模板：表头信息不符合规范,第2列应为{*设备名称}";
			return Message;
			}
			else if (excelTable[0].Columns[6].ColumnName != "稼动率（%）")
			else if (excelTable[1].Columns[2].ColumnName != "*所属组织编码")
			{
			code = "300";
			Message = "设备清单模板(设备清单)：表头信息不符合规范,第1列应为{稼动率（%）}";
			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
			{
			@@ -572,59 +690,51 @@
			#endregion

			#region【Excel模板上传验证,设备点检项目模板】
			public static string Ten(string FileCode, out string code)
			public static string Ten(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			if (excelTable.Count != 2)
			if (excelTable.Count != 1)
			{
			code = "300";
			code = "301";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable[0].Columns.Count != 6)
			else if (excelTable[0].Columns.Count != 5)
			{
			code = "300";
			code = "301";
			Message = "设备点检项目模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns[0].ColumnName != "*点检项目编号(唯一)")
			{
			code = "300";
			Message = "设备点检项目模板不符合规范：表头信息不符合规范,第1列应为{序号}";
			code = "301";
			Message = "设备点检项目模板：表头信息不符合规范,第1列应为{*点检项目编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "点检项目编号(唯一)")
			else if (excelTable[0].Columns[1].ColumnName != "*点检项目名称")
			{
			code = "300";
			Message = "设备点检项目模板不符合规范：表头信息不符合规范,第2列应为{点检项目编号(唯一)}";
			code = "301";
			Message = "设备点检项目模板：表头信息不符合规范,第2列应为{*点检项目名称}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "点检项目名称")
			else if (excelTable[0].Columns[2].ColumnName != "*点检周期")
			{
			code = "300";
			Message = "设备点检项目模板不符合规范：表头信息不符合规范,第3列应为{点检项目名称}";
			code = "301";
			Message = "设备点检项目模板：表头信息不符合规范,第3列应为{*点检周期}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "点检周期")
			else if (excelTable[0].Columns[3].ColumnName != "*是否扫码")
			{
			code = "300";
			Message = "设备点检项目模板不符合规范：表头信息不符合规范,第4列应为{点检周期}";
			code = "301";
			Message = "设备点检项目模板：表头信息不符合规范,第3列应为{*是否扫码}";
			return Message;
			}
			else if (excelTable[0].Columns[4].ColumnName != "是否扫码")
			else if (excelTable[0].Columns[4].ColumnName != "点检项目要求")
			{
			code = "300";
			Message = "设备点检项目模板不符合规范：表头信息不符合规范,第4列应为{是否扫码}";
			return Message;
			}
			else if (excelTable[0].Columns[5].ColumnName != "点检项目要求")
			{
			code = "300";
			Message = "设备点检项目模板不符合规范：表头信息不符合规范,第4列应为{点检项目要求}";
			code = "301";
			Message = "设备点检项目模板：表头信息不符合规范,第3列应为{点检项目要求}";
			return Message;
			}
			else
			@@ -637,107 +747,93 @@
			#endregion

			#region【Excel模板上传验证,设备点检标准模板】
			public static string TwentyTwo(string FileCode, out string code)
			public static string Ten_one(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			if (excelTable.Count != 4)
			if (excelTable.Count != 2)
			{
			code = "300";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable[0].Columns.Count != 5)
			else if (excelTable[0].Columns.Count != 4)
			{
			code = "300";
			Message = "设备点检标准页签模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[1].Columns.Count != 8)
			else if (excelTable[1].Columns.Count != 7)
			{
			code = "300";
			Message = "设备点检部位页签模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns[0].ColumnName != "*设备点检标准编号(唯一)")
			{
			code = "300";
			Message = "设备点检标准页签模板：表头信息不符合规范,第1列应为{序号}";
			Message = "设备点检标准页签模板：表头信息不符合规范,第1列应为{*设备点检标准编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "设备点检标准编号(唯一)")
			else if (excelTable[0].Columns[1].ColumnName != "*设备点检标准名称")
			{
			code = "300";
			Message = "设备点检标准页签模板：表头信息不符合规范,第2列应为{设备点检标准编号(唯一)}";
			Message = "设备点检标准页签模板：表头信息不符合规范,第2列应为{*设备点检标准名称}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "设备点检标准名称")
			else if (excelTable[0].Columns[2].ColumnName != "*点检管控")
			{
			code = "300";
			Message = "设备点检标准页签模板：表头信息不符合规范,第3列应为{设备点检标准名称}";
			Message = "设备点检标准页签模板：表头信息不符合规范,第3列应为{*点检管控}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "点检管控")
			else if (excelTable[0].Columns[3].ColumnName != "标准描述")
			{
			code = "300";
			Message = "设备点检标准页签模板：表头信息不符合规范,第4列应为{点检管控}";
			Message = "设备点检标准页签模板：表头信息不符合规范,第4列应为{标准描述}";
			return Message;
			}
			else if (excelTable[0].Columns[4].ColumnName != "标准描述")
			else if (excelTable[1].Columns[0].ColumnName != "*设备点检标准编号(M)")
			{
			code = "300";
			Message = "设备点检标准页签模板：表头信息不符合规范,第5列应为{标准描述}";
			Message = "设备点检部位页签模板：表头信息不符合规范,第1列应为{*设备点检标准编号(M)}";
			return Message;
			}
			else if (excelTable[1].Columns[0].ColumnName != "序号")
			else if (excelTable[1].Columns[1].ColumnName != "*点检项序号")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第1列应为{序号}";
			Message = "设备点检部位页签模板：表头信息不符合规范,第2列应为{*点检项序号}";
			return Message;
			}
			else if (excelTable[1].Columns[1].ColumnName != "点检项序号")
			else if (excelTable[1].Columns[2].ColumnName != "*设备点检部位编号(唯一)")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第2列应为{点检项序号}";
			Message = "设备点检部位页签模板：表头信息不符合规范,第3列应为{*设备点检部位编号(唯一)}";
			return Message;
			}
			else if (excelTable[1].Columns[2].ColumnName != "设备点检标准编号")
			else if (excelTable[1].Columns[3].ColumnName != "*设备点检部位名称")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第3列应为{设备点检标准编号}";
			Message = "设备点检部位页签模板：表头信息不符合规范,第4列应为{*设备点检部位名称}";
			return Message;
			}
			else if (excelTable[1].Columns[3].ColumnName != "设备点检部位编号(唯一)")
			else if (excelTable[1].Columns[4].ColumnName != "点检部位要求")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第4列应为{设备点检部位编号(唯一)}";
			Message = "设备点检部位页签模板：表头信息不符合规范,第5列应为{点检部位要求}";
			return Message;
			}
			else if (excelTable[1].Columns[4].ColumnName != "设备点检部位名称")
			else if (excelTable[1].Columns[5].ColumnName != "*选择扫码")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第5列应为{设备点检部位名称}";
			Message = "设备点检部位页签模板：表头信息不符合规范,第6列应为{*选择扫码}";
			return Message;
			}
			else if (excelTable[1].Columns[5].ColumnName != "点检部位要求")
			else if (excelTable[1].Columns[6].ColumnName != "*点检周期")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第6列应为{点检部位要求}";
			return Message;
			}
			else if (excelTable[1].Columns[6].ColumnName != "选择扫码")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第7列应为{选择扫码}";
			return Message;
			}
			else if (excelTable[1].Columns[7].ColumnName != "点检周期")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第8列应为{点检周期}";
			Message = "设备点检部位页签模板：表头信息不符合规范,第7列应为{*点检周期}";
			return Message;
			}
			else
			@@ -750,12 +846,10 @@
			#endregion

			#region【Excel模板上传验证,设备保养项目模板】
			public static string Eleven(string FileCode, out string code)
			public static string Eleven(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";
			@@ -763,37 +857,31 @@
			return Message;

			}
			else if (excelTable[0].Columns.Count != 5)
			else if (excelTable[0].Columns.Count != 4)
			{
			code = "300";
			Message = "设备保养项目模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns[0].ColumnName != "*保养项目编号(唯一)")
			{
			code = "300";
			Message = "设备保养项目模板不符合规范：表头信息不符合规范,第1列应为{序号}";
			Message = "设备保养项目模板不符合规范：表头信息不符合规范,第1列应为{*保养项目编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "保养项目编号(唯一)")
			else if (excelTable[0].Columns[1].ColumnName != "*保养项目名称")
			{
			code = "300";
			Message = "设备保养项目模板不符合规范：表头信息不符合规范,第2列应为{保养项目编号(唯一)}";
			Message = "设备保养项目模板不符合规范：表头信息不符合规范,第2列应为{*保养项目名称}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "保养项目名称")
			else if (excelTable[0].Columns[2].ColumnName != "*是否扫码")
			{
			code = "300";
			Message = "设备保养项目模板不符合规范：表头信息不符合规范,第3列应为{保养项目名称}";
			Message = "设备保养项目模板不符合规范：表头信息不符合规范,第3列应为{*是否扫码}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "是否扫码")
			{
			code = "300";
			Message = "设备保养项目模板不符合规范：表头信息不符合规范,第4列应为{是否扫码}";
			return Message;
			}
			else if (excelTable[0].Columns[4].ColumnName != "保养项目要求")
			else if (excelTable[0].Columns[3].ColumnName != "保养项目要求")
			{
			code = "300";
			Message = "设备保养项目模板不符合规范：表头信息不符合规范,第4列应为{保养项目要求}";
			@@ -809,101 +897,87 @@
			#endregion

			#region【Excel模板上传验证,设备保养标准模板】
			public static string TwentyThree(string FileCode, out string code)
			public static string Eleven_one(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			if (excelTable.Count != 4)
			if (excelTable.Count != 2)
			{
			code = "300";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable[0].Columns.Count != 5)
			else if (excelTable[0].Columns.Count != 4)
			{
			code = "300";
			Message = "设备保养标准页签模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[1].Columns.Count != 7)
			else if (excelTable[1].Columns.Count != 6)
			{
			code = "300";
			Message = "设备保养部位页签模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns[0].ColumnName != "*设备保养标准编号(唯一)")
			{
			code = "300";
			Message = "设备点检标准页签模板：表头信息不符合规范,第1列应为{序号}";
			Message = "设备保养标准页签模板：表头信息不符合规范,第1列应为{*设备保养标准编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "设备保养标准编号(唯一)")
			else if (excelTable[0].Columns[1].ColumnName != "*设备保养标准名称")
			{
			code = "300";
			Message = "设备保养标准页签模板：表头信息不符合规范,第2列应为{设备保养标准编号(唯一)}";
			Message = "设备保养标准页签模板：表头信息不符合规范,第2列应为{*设备保养标准名称}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "设备保养标准名称")
			else if (excelTable[0].Columns[2].ColumnName != "*保养周期")
			{
			code = "300";
			Message = "设备保养标准页签模板：表头信息不符合规范,第3列应为{设备保养标准名称}";
			Message = "设备保养标准页签模板：表头信息不符合规范,第3列应为{*保养周期}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "保养周期")
			else if (excelTable[0].Columns[3].ColumnName != "标准描述")
			{
			code = "300";
			Message = "设备保养标准页签模板：表头信息不符合规范,第4列应为{保养周期}";
			Message = "设备保养标准页签模板：表头信息不符合规范,第4列应为{标准描述}";
			return Message;
			}
			else if (excelTable[0].Columns[4].ColumnName != "标准描述")
			else if (excelTable[1].Columns[0].ColumnName != "*设备保养标准编号(M)")
			{
			code = "300";
			Message = "设备保养标准页签模板：表头信息不符合规范,第5列应为{标准描述}";
			Message = "设备保养部位页签模板：表头信息不符合规范,第1列应为{*设备保养标准编号(M)}";
			return Message;
			}
			else if (excelTable[1].Columns[0].ColumnName != "序号")
			else if (excelTable[1].Columns[1].ColumnName != "*保养项序号")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第1列应为{序号}";
			Message = "设备保养部位页签模板：表头信息不符合规范,第2列应为{*保养项序号}";
			return Message;
			}
			else if (excelTable[1].Columns[1].ColumnName != "保养项序号")
			else if (excelTable[1].Columns[2].ColumnName != "*设备保养部位编号(唯一)")
			{
			code = "300";
			Message = "设备保养部位页签模板：表头信息不符合规范,第2列应为{保养项序号}";
			Message = "设备保养部位页签模板：表头信息不符合规范,第3列应为{*设备保养部位编号(唯一)}";
			return Message;
			}
			else if (excelTable[1].Columns[2].ColumnName != "设备保养标准编号")
			else if (excelTable[1].Columns[3].ColumnName != "*设备保养部位名称")
			{
			code = "300";
			Message = "设备保养部位页签模板：表头信息不符合规范,第3列应为{设备保养标准编号}";
			Message = "设备保养部位页签模板：表头信息不符合规范,第4列应为{*设备保养部位名称}";
			return Message;
			}
			else if (excelTable[1].Columns[3].ColumnName != "设备保养部位编号(唯一)")
			else if (excelTable[1].Columns[4].ColumnName != "保养部位要求")
			{
			code = "300";
			Message = "设备保养部位页签模板：表头信息不符合规范,第4列应为{设备保养部位编号(唯一)}";
			Message = "设备保养部位页签模板：表头信息不符合规范,第5列应为{保养部位要求}";
			return Message;
			}
			else if (excelTable[1].Columns[4].ColumnName != "设备保养部位名称")
			else if (excelTable[1].Columns[5].ColumnName != "*选择扫码")
			{
			code = "300";
			Message = "设备保养部位页签模板：表头信息不符合规范,第5列应为{设备保养部位名称}";
			return Message;
			}
			else if (excelTable[1].Columns[5].ColumnName != "保养部位要求")
			{
			code = "300";
			Message = "设备保养部位页签模板：表头信息不符合规范,第6列应为{保养部位要求}";
			return Message;
			}
			else if (excelTable[1].Columns[6].ColumnName != "选择扫码")
			{
			code = "300";
			Message = "设备点检部位页签模板：表头信息不符合规范,第7列应为{选择扫码}";
			Message = "设备点检部位页签模板：表头信息不符合规范,第6列应为{*选择扫码}";
			return Message;
			}
			else
			@@ -915,138 +989,122 @@
			}
			#endregion

			#region【Excel模板上传验证,工装清单模板】
			public static string Twelve(string FileCode, out string code)
			#region【Excel模板上传验证,模具清单模板】
			public static string Twelve(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			if (excelTable.Columns.Count != 7)
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable.Columns[0].ColumnName != "序号")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable.Columns[1].ColumnName != "工装编号(唯一)")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable.Columns[2].ColumnName != "工装名称（唯一）")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable.Columns[3].ColumnName != "工装类型")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable.Columns[4].ColumnName != "型腔数量")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable.Columns[5].ColumnName != "理论寿命（次）")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable.Columns[6].ColumnName != "使用状态")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else
			{
			code = "200";
			Message = "模板检验通过";
			}
			return Message;
			}
			#endregion

			#region【Excel模板上传验证,工装点检模板】
			public static string Thirteen(string FileCode, 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 != 6)
			{
			code = "301";
			Message = "模具清单模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[1].Columns.Count != 2)
			{
			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[0].Columns[3].ColumnName != "*状态")
			{
			code = "301";
			Message = "模具清单模板：表头信息不符合规范,第4列应为{*状态}";
			return Message;
			}
			else if (excelTable[0].Columns[4].ColumnName != "预计寿命(次)")
			{
			code = "301";
			Message = "模具清单模板：表头信息不符合规范,第5列应为{预计寿命(次)}";
			return Message;
			}
			else if (excelTable[0].Columns[5].ColumnName != "剩余寿命(次)")
			{
			code = "301";
			Message = "模具清单模板：表头信息不符合规范,第6列应为{剩余寿命(次)}";
			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
			{
			code = "200";
			Message = "模板检验通过";
			}
			return Message;
			}
			#endregion

			#region【Excel模板上传验证,模具点检项模板】
			public static string Thirteen(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			if (excelTable.Count != 1)
			{
			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[0].Columns[0].ColumnName != "*点检项目编号(唯一)")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名字段数";
			code = "301";
			Message = "模具点检项目模板：表头信息不符合规范,第1列应为{*点检项目编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns[1].ColumnName != "*点检项目名称")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "模具点检项目模板：表头信息不符合规范,第2列应为{*点检项目名称}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "点检标准(唯一)")
			else if (excelTable[0].Columns[2].ColumnName != "要求描述")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable[0].Columns[2].ColumnName != "标准名称（唯一）")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable[1].Columns[0].ColumnName != "序号")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable[1].Columns[1].ColumnName != "点检标准")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable[1].Columns[2].ColumnName != "标准名称")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable[1].Columns[3].ColumnName != "SEQ(部位顺序)")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable[1].Columns[4].ColumnName != "部位条码（唯一）")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable[1].Columns[5].ColumnName != "部位名称")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable[1].Columns[6].ColumnName != "点检要求")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable[1].Columns[7].ColumnName != "点检周期")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "模具点检项目模板：表头信息不符合规范,第3列应为{要求描述}";
			return Message;
			}
			else
			{
			@@ -1057,82 +1115,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 != "*模具点检标准编号(M)")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "关联模具点检部位模板：表头信息不符合规范,第1列应为{*模具点检标准编号(M)}";
			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 != "*模具保养标准编号(M)")
			{
			code = "301";
			Message = "关联模具保养部位模板：表头信息不符合规范,第1列应为{*模具保养标准编号(M)}";
			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
			{
			@@ -1144,36 +1323,52 @@
			#endregion

			#region【Excel模板上传验证,工序定义模板】
			public static string Fifteen(string FileCode, out string code)
			public static string Fifteen(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			if (excelTable.Columns.Count != 4)
			if (excelTable.Count != 1)
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable.Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns.Count != 5)
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "工序设置模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable.Columns[1].ColumnName != "工序编码(唯一)")
			else if (excelTable[0].Columns[0].ColumnName != "*工序编号(唯一)")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "工序设置模板：表头信息不符合规范,第1列应为{*工序编号(唯一)}";
			return Message;
			}
			else if (excelTable.Columns[2].ColumnName != "工序名称（唯一）")
			else if (excelTable[0].Columns[1].ColumnName != "*工序名称")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "工序设置模板：表头信息不符合规范,第2列应为{*工序名称}";
			return Message;
			}
			else if (excelTable.Columns[3].ColumnName != "启用状态")
			else if (excelTable[0].Columns[2].ColumnName != "*工序类型")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			code = "301";
			Message = "工序设置模板：表头信息不符合规范,第3列应为{*工序类型}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "*状态")
			{
			code = "301";
			Message = "工序设置模板：表头信息不符合规范,第1列应为{*状态}";
			return Message;
			}
			else if (excelTable[0].Columns[4].ColumnName != "描述")
			{
			code = "301";
			Message = "工序设置模板：表头信息不符合规范,第2列应为{描述}";
			return Message;
			}
			else
			{
			@@ -1490,47 +1685,39 @@
			#endregion

			#region【Excel模板上传验证,缺陷定义模板】
			public static string Eighteen(string FileCode, out string code)
			public static string Eighteen(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			if (excelTable.Count != 2)
			if (excelTable.Count != 1)
			{
			code = "300";
			code = "301";
			Message = "导入模板不符合规范,请检查sheet数";
			return Message;

			}
			else if (excelTable[0].Columns.Count != 4)
			else if (excelTable[0].Columns.Count != 3)
			{
			code = "300";
			code = "301";
			Message = "缺陷定义模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns[0].ColumnName != "*缺陷编号(唯一)")
			{
			code = "300";
			Message = "缺陷定义模板不符合规范：表头信息不符合规范,第1列应为{序号}";
			code = "301";
			Message = "缺陷定义模板：表头信息不符合规范,第1列应为{*缺陷编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "缺陷编号(唯一)")
			else if (excelTable[0].Columns[1].ColumnName != "*缺陷名称")
			{
			code = "300";
			Message = "缺陷定义模板不符合规范：表头信息不符合规范,第2列应为{缺陷编号(唯一)}";
			code = "301";
			Message = "缺陷定义模板：表头信息不符合规范,第2列应为{*缺陷名称}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "缺陷名称")
			else if (excelTable[0].Columns[2].ColumnName != "缺陷描述")
			{
			code = "300";
			Message = "缺陷定义模板不符合规范：表头信息不符合规范,第3列应为{缺陷名称}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "缺陷描述")
			{
			code = "300";
			Message = "缺陷描述模板不符合规范：表头信息不符合规范,第4列应为{缺陷描述}";
			code = "301";
			Message = "缺陷定义模板：表头信息不符合规范,第3列应为{缺陷描述}";
			return Message;
			}
			else
			@@ -1793,7 +1980,7 @@
			var dynamicParams = new DynamicParameters();
			DataTable dt;
			List<ExcelErro> list = new List<ExcelErro>();


			if (list.Count > 0)
			{
			int index = 0;
			@@ -1815,7 +2002,7 @@
			#endregion

			#region【Excel上传数据验证,岗位管理】
			public static List<ExcelErro> OneData(string FileCode, out string StuCode, out string message, out int count)
			public static List<ExcelErro> OneData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			@@ -1824,121 +2011,38 @@
			var dynamicParams = new DynamicParameters();
			DataTable dt;
			List<ExcelErro> list = new List<ExcelErro>();
			List<DataTable> excelTable = new List<DataTable>();
			list = ImportExcel.ExcelToTableListErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTableList(FileCode); //获取Excel数据
			//主表
			for (int j = 0; j < excelTable[0].Rows.Count; j++)
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//岗位表
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			{
			if (excelTable[1].Rows[j][1].ToString().Trim() != null && excelTable[1].Rows[j][1].ToString().Trim() != "")
			if (excelTable[0].Rows[k][0].ToString().Trim() != null && excelTable[0].Rows[k][0].ToString().Trim() != "")
			{
			sql = @"select * from TOrganization where org_code=@org_code";
			dynamicParams.Add("@org_code", excelTable[1].Rows[j][1].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt == null \|\| dt.Rows.Count <= 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{组织编码}";
			erro.ErrorCont = "角色类型表:{组织编码}字段" + excelTable[1].Rows[j][1].ToString().Trim() + "不存在";
			list.Add(erro);
			}
			}
			if (excelTable[0].Rows[j][2].ToString().Trim() != null && excelTable[0].Rows[j][2].ToString().Trim() != "")
			{
			sql = @"select * from TRoleType where roletype_code=@roletype_code";
			dynamicParams.Add("@roletype_code", excelTable[0].Rows[j][2].ToString().Trim());
			sql = @"select * from TPost where postcode=@postcode";
			dynamicParams.Add("@postcode", 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[j][2].ToString().Trim() + "已存在";
			erro.ErrorField = "{*岗位编号(唯一)}";
			erro.ErrorCont = "岗位表:{*岗位编号(唯一)}字段" + excelTable[0].Rows[k][0].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			}
			//子表
			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() != "")
			if (excelTable[0].Rows[k][1].ToString().Trim() != null && excelTable[0].Rows[k][1].ToString().Trim() != "")
			{
			sql = @"select * from TRole where role_code=@role_code";
			dynamicParams.Add("@role_code", excelTable[1].Rows[k][2].ToString().Trim());
			sql = @"select * from TPost where postname=@postname";
			dynamicParams.Add("@postname", 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[1].Rows[k][2].ToString().Trim() + "已存在";
			erro.ErrorField = "{*岗位名称}";
			erro.ErrorCont = "岗位表:{*岗位名称}字段" + excelTable[0].Rows[k][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[1].Rows[k][1].ToString().Trim() != null && excelTable[1].Rows[k][1].ToString().Trim() != "")
			{
			sql = @"select * from TOrganization where org_code=@org_code";
			dynamicParams.Add("@org_code", excelTable[1].Rows[k][1].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt == null \|\| dt.Rows.Count <= 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{组织编码}";
			erro.ErrorCont = "角色表:{组织编码}字段" + excelTable[1].Rows[k][1].ToString().Trim() + "不存在";
			list.Add(erro);
			}
			}
			if (excelTable[1].Rows[k][4].ToString().Trim() != null && excelTable[1].Rows[k][4].ToString().Trim() != "")
			{
			sql = @"select torg_code from TRoleType where roletype_code=@roletype_code";
			dynamicParams.Add("@roletype_code", excelTable[1].Rows[k][4].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt != null && dt.Rows.Count > 0)
			{
			if (dt.Rows[0]["torg_code"].ToString() != excelTable[1].Rows[k][1].ToString().Trim())
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{角色类型编码}";
			erro.ErrorCont = "角色表:{角色类型编码}字段" + excelTable[1].Rows[k][4].ToString().Trim() + " 不是组织编码:" + excelTable[1].Rows[k][1].ToString().Trim() + "下的角色组";
			list.Add(erro);
			}
			}
			}
			}
			//判断子表组织编码不存在于主表组织编码中的数据
			var dt2 = 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> listRow2 = dt2.ToList();
			if (listRow2.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{组织编码}";
			erro.ErrorCont = "角色表:{组织编码}字段中有值在角色类型表:{组织编码}中不存在";
			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)
			{
			@@ -1962,15 +2066,65 @@
			#endregion

			#region【Excel上传数据验证,班组管理】
			public static List<ExcelErro> TwoData(string FileCode, out string StuCode, out string message, out int count)
			public static List<ExcelErro> TwoData(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 TGroup where usergroupcode=@usergroupcode";
			dynamicParams.Add("@usergroupcode", 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 TGroup where usergroupname=@usergroupname";
			dynamicParams.Add("@usergroupname", 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
			@@ -2050,7 +2204,7 @@
			list.Add(erro);
			}
			}
			else
			else
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = (k + 1).ToString();
			@@ -2138,35 +2292,93 @@
			#endregion

			#region【Excel上传数据验证,角色管理】
			public static List<ExcelErro> FourData(string FileCode, out string StuCode, out string message, out int count)
			public static List<ExcelErro> FourData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			count = 0;
			string sql = "";
			DataTable dt;
			var dynamicParams = new DynamicParameters();
			DataTable dt;
			List<ExcelErro> list = new List<ExcelErro>();
			DataTable excelTable = new DataTable();
			list = ImportExcel.ExcelToTableErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTable(FileCode); //获取Excel数据
			for (int i = 0; i < excelTable.Rows.Count; i++)
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//角色表
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			{
			if (excelTable.Rows[i][1].ToString().Trim() != null && excelTable.Rows[i][1].ToString().Trim() != "")
			if (excelTable[0].Rows[k][0].ToString().Trim() != null && excelTable[0].Rows[k][0].ToString().Trim() != "")
			{
			sql = @"select code from TCustomer where code=@code";

			dynamicParams.Add("@code", excelTable.Rows[i][1].ToString().Trim());
			sql = @"select * from TRole where rolecode=@rolecode";
			dynamicParams.Add("@rolecode", 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.Rows[i][1].ToString().Trim() + "已存在";
			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 TRole where rolename=@rolename";
			dynamicParams.Add("@rolename", 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 (excelTable[0].Rows[k][3].ToString().Trim() != null && excelTable[0].Rows[k][3].ToString().Trim() != "")
			//{
			// if (excelTable[0].Rows[k][3].ToString().Trim() == "自定义")
			// {
			// if (excelTable[0].Rows[k][4].ToString().Trim() == null && excelTable[0].Rows[k][4].ToString().Trim() == "")
			// {
			// ExcelErro erro = new ExcelErro();
			// erro.RoeNumber = "/";
			// erro.ErrorField = "{数据权限}";
			// erro.ErrorCont = "角色表:{数据范围}字段为：" + excelTable[1].Rows[k][3].ToString().Trim() + "时,{数据权限}字段不能为空";
			// list.Add(erro);
			// }
			// else
			// {
			// //判断数据权限编码是否合理
			// if (excelTable[0].Rows[k][4].ToString().Trim() != null && excelTable[0].Rows[k][4].ToString().Trim() != "")
			// {
			// string[] torgcode = Array.ConvertAll<string, string>(excelTable[0].Rows[k][4].ToString().Trim().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries), s => s.ToString()); //string分割转string[]
			// sql = @"select postcode from TOrganization where torg_code in @torgcode";
			// dynamicParams.Add("@torgcode", torgcode);
			// dt = DapperHelper.selectdata(sql, dynamicParams);
			// if (dt != null && dt.Rows.Count > 0)
			// {
			// string[] values = excelTable[0].Rows[k][4].ToString().Trim().Split(',');
			// var unmatchedValues = values.Except(dt.AsEnumerable().Select(row => row.Field<string>("torg_code")));
			// foreach (var value in unmatchedValues)
			// {
			// ExcelErro erro = new ExcelErro();
			// erro.RoeNumber = (k + 1).ToString();
			// erro.ErrorField = "{数据权限}";
			// erro.ErrorCont = "角色表:{数据权限}字段" + value + " 不是有效的组织编码";
			// list.Add(erro);
			// }
			// }
			// else
			// {
			// ExcelErro erro = new ExcelErro();
			// erro.RoeNumber = (k + 1).ToString();
			// erro.ErrorField = "{数据权限}";
			// erro.ErrorCont = "角色表:{数据权限}字段" + excelTable[0].Rows[k][4].ToString().Trim() + " 不是有效的组织编码";
			// list.Add(erro);
			// }
			// }
			// }
			// }
			//}
			}
			if (list.Count > 0)
			{
			@@ -2183,14 +2395,14 @@
			{
			StuCode = "200";
			message = "数据验证成功";
			count = excelTable.Rows.Count;
			count = excelTable[0].Rows.Count;
			}
			return list;
			}
			#endregion

			#region【Excel上传数据验证,往来单位】
			public static List<ExcelErro> FiveData(string FileCode, out string StuCode, out string message, out int count)
			public static List<ExcelErro> FiveData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			@@ -2199,93 +2411,82 @@
			DataTable dt;
			var dynamicParams = new DynamicParameters();
			List<ExcelErro> list = new List<ExcelErro>();
			DataTable excelTable = new DataTable();
			list = ImportExcel.ExcelToTableErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTable(FileCode); //获取Excel数据
			for (int i = 0; i < excelTable.Rows.Count; i++)
			{
			if (excelTable.Rows[i][1].ToString().Trim() != null && excelTable.Rows[i][1].ToString().Trim() != "")
			{
			sql = @"select code from TCustomer where code=@code";

			dynamicParams.Add("@code", excelTable.Rows[i][1].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt.Rows.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{往来单位编码(唯一)}";
			erro.ErrorCont = "往来单位表:{往来单位编码(唯一)}字段" + excelTable.Rows[i][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.Rows.Count;
			}
			return list;
			}
			#endregion

			#region【Excel上传数据验证,仓库设置】
			public static List<ExcelErro> SixData(string FileCode, 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<DataTable> excelTable = new List<DataTable>();
			list = ImportExcel.ExcelToTableListErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTableList(FileCode); //获取Excel数据
			//仓库表
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//往来单位类型表
			for (int j = 0; j < excelTable[0].Rows.Count; j++)
			{
			if (excelTable[0].Rows[j][1].ToString().Trim() != null && excelTable[0].Rows[j][1].ToString().Trim() != "")
			if (excelTable[0].Rows[j][0].ToString().Trim() != null && excelTable[0].Rows[j][0].ToString().Trim() != "")
			{
			sql = @"select * from T_Sec_Stck where code=@code";
			dynamicParams.Add("@code", excelTable[0].Rows[j][1].ToString().Trim());
			sql = @"select * from TCustomerType 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][1].ToString().Trim() + "已存在";
			erro.ErrorField = "{*往来单位类型编号(唯一)}";
			erro.ErrorCont = "往来单位类型表:{*往来单位类型编号(唯一)}字段" + excelTable[0].Rows[j][0].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[0].Rows[j][1].ToString().Trim() != null && excelTable[0].Rows[j][1].ToString().Trim() != "")
			{
			sql = @"select * from TCustomerType where name=@name";
			dynamicParams.Add("@name", excelTable[0].Rows[j][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[j][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			}
			//库位表
			var invalidRows = excelTable[0].AsEnumerable().Where(row =>
			row.Field<string>("上级编码") == row.Field<string>("*往来单位类型编号(唯一)") \|\|
			(row.Field<string>("上级编码") != null && !excelTable[0].AsEnumerable().Any(r => r.Field<string>("*往来单位类型编号(唯一)") == row.Field<string>("上级编码")))
			);

			// 输出不合理的行
			foreach (var row in invalidRows)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{上级编码}";
			erro.ErrorCont = $"往来单位类型表:往来单位类型编号(唯一)： {row.Field<string>("往来单位类型编号(唯一)")} 的上级编码：{row.Field<string>("上级编码")}不合理";
			list.Add(erro);
			}

			//往来单位表
			for (int k = 0; k < excelTable[1].Rows.Count; k++)
			{
			if (excelTable[1].Rows[k][1].ToString().Trim() != null && excelTable[1].Rows[k][1].ToString().Trim() != "")
			if (excelTable[1].Rows[k][0].ToString().Trim() != null && excelTable[1].Rows[k][0].ToString().Trim() != "")
			{
			sql = @"select * from T_Sec_Loca where code=@code";
			dynamicParams.Add("@code", excelTable[1].Rows[k][1].ToString().Trim());
			sql = @"select * from TCustomer where code=@code";
			dynamicParams.Add("@code", excelTable[1].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[1].Rows[k][2].ToString().Trim() + "已存在";
			erro.ErrorField = "{*往来单位编号(唯一)}";
			erro.ErrorCont = "往来单位表:{*往来单位编号(唯一)}字段" + excelTable[1].Rows[k][0].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[1].Rows[k][1].ToString().Trim() != null && excelTable[1].Rows[k][1].ToString().Trim() != "")
			{
			sql = @"select * from TCustomer where name=@name";
			dynamicParams.Add("@name", excelTable[1].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[1].Rows[k][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			@@ -2294,16 +2495,16 @@
			var dt3 = from r in excelTable[1].AsEnumerable()
			where !(
			from rr in excelTable[0].AsEnumerable()
			select rr.Field<string>("仓库编号(唯一)")
			).Contains(r.Field<string>("所属仓库编码"))
			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 = "库位表:{所属仓库编码}字段中有值在仓库表:{仓库编号(唯一)}中不存在";
			erro.ErrorField = "{*往来单位类型编码}";
			erro.ErrorCont = "往来单位表:{往来单位类型编码}字段中有值在往来单位类型表:{往来单位类型编号(唯一)}中不存在";
			list.Add(erro);
			}
			if (list.Count > 0)
			@@ -2327,36 +2528,8 @@
			}
			#endregion

			#region【Excel上传数据验证,库位设置】
			public static List<ExcelErro> SevenData(string FileCode, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			count = 0;
			string sql = "";
			DataTable dt;
			List<ExcelErro> list = new List<ExcelErro>();

			return list;
			}
			#endregion

			#region【Excel上传数据验证,存货档案】
			public static List<ExcelErro> EightData(string FileCode, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			count = 0;
			string sql = "";
			DataTable dt;
			List<ExcelErro> list = new List<ExcelErro>();

			return list;
			}
			#endregion

			#region【Excel上传数据验证,设备清单】
			public static List<ExcelErro> NineData(string FileCode, out string StuCode, out string message, out int count)
			#region【Excel上传数据验证,仓库设置】
			public static List<ExcelErro> SixData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			@@ -2365,45 +2538,132 @@
			var dynamicParams = new DynamicParameters();
			DataTable dt;
			List<ExcelErro> list = new List<ExcelErro>();
			DataTable excelTable = new DataTable();
			list = ImportExcel.ExcelToTableErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTable(FileCode); //获取Excel数据
			//设备清单表
			for (int k = 0; k < excelTable.Rows.Count; k++)
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//仓库表
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			{
			if (excelTable.Rows[k][1].ToString().Trim() != null && excelTable.Rows[k][1].ToString().Trim() != "")
			if (excelTable[0].Rows[k][0].ToString().Trim() != null && excelTable[0].Rows[k][0].ToString().Trim() != "")
			{
			sql = @"select * from TEqpInfo where code=@code";
			dynamicParams.Add("@code", excelTable.Rows[k][1].ToString().Trim());
			sql = @"select * from TSecStck 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.Rows[k][1].ToString().Trim() + "已存在";
			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 TSecStck 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[1].Rows[k][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			}
			//车间判断
			for (int m = 0; m < excelTable.Rows.Count; m++)
			if (list.Count > 0)
			{
			if (excelTable.Rows[m][4].ToString().Trim() != null && excelTable.Rows[m][4].ToString().Trim() != "")
			int index = 0;
			foreach (ExcelErro item in list)
			{
			sql = @"select * from TOrganization where org_code=@code and description='W'";
			dynamicParams.Add("@code", excelTable.Rows[m][4].ToString().Trim());
			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> SevenData(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 TSecLoca 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 TSecLoca 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[1].Rows[k][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[0].Rows[k][2].ToString().Trim() != null && excelTable[0].Rows[k][2].ToString().Trim() != "")
			{
			sql = @"select * from TSecStck where code=@code";
			dynamicParams.Add("@code", excelTable[0].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.Rows[m][4].ToString().Trim() + "不存在";
			erro.ErrorField = "{*所属仓库编码}";
			erro.ErrorCont = "库位表:{*所属仓库编码}字段" + excelTable[1].Rows[k][1].ToString().Trim() + "不存在";
			list.Add(erro);
			}
			}
			}
			var invalidRows = excelTable[0].AsEnumerable().Where(row =>
			row.Field<string>("上级库位编码") == row.Field<string>("*库位编号(唯一)") \|\|
			(row.Field<string>("上级库位编码") != null && !excelTable[0].AsEnumerable().Any(r => r.Field<string>("*库位编号(唯一)") == row.Field<string>("上级库位编码")))
			);

			// 输出不合理的行
			foreach (var row in invalidRows)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{上级库位编码}";
			erro.ErrorCont = $"库位表:库位编号(唯一)： {row.Field<string>("库位编号(唯一)")} 的上级库位编码：{row.Field<string>("上级库位编码")}不合理";
			list.Add(erro);
			}

			if (list.Count > 0)
			{
			int index = 0;
			@@ -2419,16 +2679,15 @@
			{
			StuCode = "200";
			message = "数据验证成功";
			count = excelTable.Rows.Count;
			count = excelTable[0].Rows.Count;
			}
			return list;
			}
			#endregion

			#region【Excel上传数据验证,设备点检项目】
			public static List<ExcelErro> TenData(string FileCode, out string StuCode, out string message, out int count)
			#region【Excel上传数据验证,存货档案】
			public static List<ExcelErro> EightData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{

			message = "";
			StuCode = "";
			count = 0;
			@@ -2436,137 +2695,138 @@
			DataTable dt;
			var dynamicParams = new DynamicParameters();
			List<ExcelErro> list = new List<ExcelErro>();
			DataTable excelTable = new DataTable();
			list = ImportExcel.ExcelToTableErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTable(FileCode); //获取Excel数据
			//当前Excel数据中点检标准页签中,设备点检标准编号(唯一是否有重复)
			DataTable distinct = excelTable.DefaultView.ToTable(true, "点检项目编号(唯一)");
			if (distinct.Rows.Count != excelTable.Rows.Count)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{点检项目编号(唯一)}";
			erro.ErrorCont = "设备点检项目页签模板:{点检项目编号(唯一)}有重复";
			list.Add(erro);
			}
			for (int i = 0; i < excelTable.Rows.Count; i++)
			{
			if (excelTable.Rows[i][1].ToString().Trim() != null && excelTable.Rows[i][1].ToString().Trim() != "")
			{
			sql = @"select code from TEqpchk_Item where code=@code";

			dynamicParams.Add("@code", excelTable.Rows[i][1].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt.Rows.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{点检项目编号(唯一)}";
			erro.ErrorCont = "设备点检项目表:{点检项目编号(唯一)}字段" + excelTable.Rows[i][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.Rows.Count;
			}
			return list;
			}
			#endregion

			#region【Excel上传数据验证,设备点检标准】
			public static List<ExcelErro> TwentyTwoData(string FileCode, 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<DataTable> excelTable = new List<DataTable>();
			list = ImportExcel.ExcelToTableListErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTableList(FileCode); //获取Excel数据
			//当前Excel数据中点检标准页签中,设备点检标准编号(唯一是否有重复)
			DataTable distinct = excelTable[0].DefaultView.ToTable(true, "设备点检标准编号(唯一)");
			if (distinct.Rows.Count != excelTable[0].Rows.Count)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{设备点检标准编号(唯一)}";
			erro.ErrorCont = "设备点检标准页签模板:{设备点检标准编号(唯一)}有重复";
			list.Add(erro);
			}
			//设备点检标准表是否已存在点检标准
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//存货分类表
			for (int j = 0; j < excelTable[0].Rows.Count; j++)
			{
			if (excelTable[0].Rows[j][1].ToString().Trim() != null && excelTable[0].Rows[j][1].ToString().Trim() != "")
			if (excelTable[0].Rows[j][0].ToString().Trim() != null && excelTable[0].Rows[j][0].ToString().Trim() != "")
			{
			sql = @"select * from TEqpchk_Main where code=@code";
			dynamicParams.Add("@code", excelTable[0].Rows[j][1].ToString().Trim());
			sql = @"select * from TMateriel_Class 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][1].ToString().Trim() + "在数据表中已存在";
			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][1].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][2].ToString().Trim() + " 对应{设备点检部位编号(唯一)}有重复";
			list.Add(erro);
			}
			}
			else
			}
			if (excelTable[0].Rows[j][1].ToString().Trim() != null && excelTable[0].Rows[j][1].ToString().Trim() != "")
			{
			sql = @"select * from TMateriel_Class where name=@name";
			dynamicParams.Add("@name", excelTable[0].Rows[j][1].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[j][2].ToString().Trim() + " 在设备点检标准页签模板中不存在";
			erro.ErrorField = "{*存货分类名称}";
			erro.ErrorCont = "存货分类表:{*存货分类名称}字段" + excelTable[0].Rows[j][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			}
			//当前Excel数据中点检部位页签中,设备点检部位编号(唯一)在设备点检部位表中是否存在
			var invalidRows = excelTable[0].AsEnumerable().Where(row =>
			row.Field<string>("上级编码") == row.Field<string>("*存货分类编号(唯一)") \|\|
			(row.Field<string>("上级编码") != null && !excelTable[0].AsEnumerable().Any(r => r.Field<string>("*存货分类编号(唯一)") == row.Field<string>("上级编码")))
			);

			// 输出不合理的行
			foreach (var row in invalidRows)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{上级编码}";
			erro.ErrorCont = $"存货类型表:存货分类编号(唯一)： {row.Field<string>("*存货分类编号(唯一)")} 的上级编码：{row.Field<string>("上级编码")}不合理";
			list.Add(erro);
			}

			//存货表
			for (int k = 0; k < excelTable[1].Rows.Count; k++)
			{
			if (excelTable[1].Rows[k][3].ToString().Trim() != null && excelTable[1].Rows[k][3].ToString().Trim() != "")
			if (excelTable[1].Rows[k][0].ToString().Trim() != null && excelTable[1].Rows[k][0].ToString().Trim() != "")
			{
			sql = @"select * from TEqpchk_Item where code=@code";
			dynamicParams.Add("@code", excelTable[1].Rows[k][3].ToString().Trim());
			sql = @"select * from TMateriel_Info where partcode=@partcode";
			dynamicParams.Add("@partcode", excelTable[1].Rows[k][0].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt.Rows.Count < 0)
			if (dt.Rows.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{设备点检部位编号(唯一)}";
			erro.ErrorCont = "设备点检部位表:{设备点检部位编号(唯一)}字段" + excelTable[1].Rows[k][2].ToString().Trim() + "在数据表中不存在";
			erro.ErrorField = "{*存货编号(唯一)}";
			erro.ErrorCont = "存货档案表:{*存货编号(唯一)}字段" + excelTable[1].Rows[k][0].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[1].Rows[k][1].ToString().Trim() != null && excelTable[1].Rows[k][1].ToString().Trim() != "")
			{
			sql = @"select * from TMateriel_Info where partname=@partname";
			dynamicParams.Add("@partname", excelTable[1].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[1].Rows[k][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[1].Rows[k][5].ToString().Trim() != null && excelTable[1].Rows[k][5].ToString().Trim() != "")
			{
			switch (excelTable[1].Rows[k][5].ToString().Trim())
			{
			case "S": //单计量
			//判断计量单位是否为单计量
			if (excelTable[1].Rows[k][6].ToString().Trim() != null && excelTable[1].Rows[k][6].ToString().Trim() != "")
			{
			sql = @"select * from TUnit where name=@name and isSingleUnit='1'";
			dynamicParams.Add("@name", excelTable[1].Rows[k][6].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][6].ToString().Trim() + "不是有效的单计量单位";
			list.Add(erro);
			}
			}
			break;
			case "M": //多计量
			//判断计量单位是否为多计量
			if (excelTable[1].Rows[k][6].ToString().Trim() != null && excelTable[1].Rows[k][6].ToString().Trim() != "")
			{
			sql = @"select * from TUnitGroup where name=@name";
			dynamicParams.Add("@code", excelTable[1].Rows[k][6].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][6].ToString().Trim() + "不是有效的多计量单位组";
			list.Add(erro);
			}
			}
			break;
			default:
			break;
			}
			}
			if (excelTable[1].Rows[k][7].ToString().Trim() != null && excelTable[1].Rows[k][7].ToString().Trim() != "")
			{
			sql = @"select * from TSecStck where code=@code";
			dynamicParams.Add("@code", excelTable[1].Rows[k][7].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][7].ToString().Trim() + "不是有效的仓库编码";
			list.Add(erro);
			}
			}
			@@ -2575,16 +2835,322 @@
			var dt3 = from r in excelTable[1].AsEnumerable()
			where !(
			from rr in excelTable[0].AsEnumerable()
			select rr.Field<string>("设备点检标准编号(唯一)")
			).Contains(r.Field<string>("设备点检标准编号"))
			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 = "设备点检部位页签模板:{设备点检标准编号}字段中有值在设备点检标准页签模板:{设备点检标准编号(唯一)}中不存在";
			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> NineData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			count = 0;
			string sql = "";
			DataTable dt;
			var dynamicParams = new DynamicParameters();
			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 TEqpType 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);
			}
			}
			if (excelTable[0].Rows[j][1].ToString().Trim() != null && excelTable[0].Rows[j][1].ToString().Trim() != "")
			{
			sql = @"select * from TEqpType where name=@name";
			dynamicParams.Add("@name", excelTable[0].Rows[j][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[j][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			}

			//设备表
			for (int k = 0; k < excelTable[1].Rows.Count; k++)
			{
			if (excelTable[1].Rows[k][0].ToString().Trim() != null && excelTable[1].Rows[k][0].ToString().Trim() != "")
			{
			sql = @"select * from TEqpInfo where code=@code";
			dynamicParams.Add("@code", excelTable[1].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[1].Rows[k][0].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[1].Rows[k][1].ToString().Trim() != null && excelTable[1].Rows[k][1].ToString().Trim() != "")
			{
			sql = @"select * from TEqpInfo where name=@name";
			dynamicParams.Add("@name", excelTable[1].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[1].Rows[k][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[1].Rows[k][2].ToString().Trim() != null && excelTable[1].Rows[k][2].ToString().Trim() != "")
			{
			sql = @"select * from TOrganization where torg_code=@torg_code";
			dynamicParams.Add("@torg_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> TenData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{

			message = "";
			StuCode = "";
			count = 0;
			string sql = "";
			DataTable dt;
			var dynamicParams = new DynamicParameters();
			List<ExcelErro> list = new List<ExcelErro>();
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//当前Excel数据中点检标准页签中,设备点检标准编号(唯一是否有重复)
			DataTable distinct = excelTable[0].DefaultView.ToTable(true, "*点检项目编号(唯一)");
			if (distinct.Rows.Count != excelTable[0].Rows.Count)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{*点检项目编号(唯一)}";
			erro.ErrorCont = "设备点检项目模板:{*点检项目编号(唯一)}有重复";
			list.Add(erro);
			}
			for (int i = 0; i < excelTable[0].Rows.Count; i++)
			{
			if (excelTable[0].Rows[i][0].ToString().Trim() != null && excelTable[0].Rows[i][0].ToString().Trim() != "")
			{
			sql = @"select code from TEqpchk_Item where code=@code";

			dynamicParams.Add("@code", excelTable[0].Rows[i][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[i][0].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> Ten_oneData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			count = 0;
			string sql = "";
			DataTable dt;
			var dynamicParams = new DynamicParameters();
			List<ExcelErro> list = new List<ExcelErro>();
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//当前Excel数据中点检标准页签中,设备点检标准编号(唯一是否有重复)
			DataTable distinct = excelTable[0].DefaultView.ToTable(true, "*设备点检标准编号(唯一)");
			if (distinct.Rows.Count != excelTable[0].Rows.Count)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{*设备点检标准编号(唯一)}";
			erro.ErrorCont = "设备点检标准页签模板:{*设备点检标准编号(唯一)}有重复";
			list.Add(erro);
			}
			//设备点检标准表是否已存在点检标准
			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 TEqpchk_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["*设备点检标准编号(M)"].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 = "设备点检部位页签模板:{设备点检标准编号(M)}:" + excelTable[1].Rows[j][1].ToString().Trim() + " 对应{设备点检部位编号(唯一)}有重复";
			list.Add(erro);
			}
			}
			else
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{*设备点检标准编号(唯一)}";
			erro.ErrorCont = "设备点检标准模板sheet1中:{设备点检标准编号(M)}:" + excelTable[1].Rows[j][0].ToString().Trim() + " 在设备点检标准模板sheet中{设备点检标准编号(唯一)}列不存在";
			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 TEqpchk_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>("*设备点检标准编号(M)"))
			select r;
			List<DataRow> listRow = dt3.ToList();
			if (listRow.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{*设备点检标准编号(M)}";
			erro.ErrorCont = "设备点检部位页签模板:{设备点检标准编号(M)}字段中有值在设备点检标准页签模板:{设备点检标准编号(唯一)}中不存在";
			list.Add(erro);
			}
			if (list.Count > 0)
			@@ -2609,7 +3175,7 @@
			#endregion

			#region【Excel上传数据验证,设备保养项目】
			public static List<ExcelErro> ElevenData(string FileCode, out string StuCode, out string message, out int count)
			public static List<ExcelErro> ElevenData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			@@ -2618,33 +3184,31 @@
			DataTable dt;
			var dynamicParams = new DynamicParameters();
			List<ExcelErro> list = new List<ExcelErro>();
			DataTable excelTable = new DataTable();
			list = ImportExcel.ExcelToTableErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTable(FileCode); //获取Excel数据
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//当前Excel数据中点检标准页签中,设备点检标准编号(唯一是否有重复)
			DataTable distinct = excelTable.DefaultView.ToTable(true, "保养项目编号(唯一)");
			if (distinct.Rows.Count != excelTable.Rows.Count)
			DataTable distinct = excelTable[0].DefaultView.ToTable(true, "*保养项目编号(唯一)");
			if (distinct.Rows.Count != excelTable[0].Rows.Count)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{保养项目编号(唯一)}";
			erro.ErrorCont = "设备保养项目页签模板:{保养项目编号(唯一)}有重复";
			erro.ErrorField = "{*保养项目编号(唯一)}";
			erro.ErrorCont = "设备保养项目页签模板:{*保养项目编号(唯一)}有重复";
			list.Add(erro);
			}
			for (int i = 0; i < excelTable.Rows.Count; i++)
			for (int i = 0; i < excelTable[0].Rows.Count; i++)
			{
			if (excelTable.Rows[i][1].ToString().Trim() != null && excelTable.Rows[i][1].ToString().Trim() != "")
			if (excelTable[0].Rows[i][0].ToString().Trim() != null && excelTable[0].Rows[i][0].ToString().Trim() != "")
			{
			sql = @"select code from TEqpmai_Item where code=@code";

			dynamicParams.Add("@code", excelTable.Rows[i][1].ToString().Trim());
			dynamicParams.Add("@code", excelTable[0].Rows[i][0].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt.Rows.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{保养项目编号(唯一)}";
			erro.ErrorCont = "设备保养项目表:{点检保养编号(唯一)}字段" + excelTable.Rows[i][1].ToString().Trim() + "已存在";
			erro.ErrorField = "{*保养项目编号(唯一)}";
			erro.ErrorCont = "设备保养项目表:{*点检保养编号(唯一)}字段" + excelTable[0].Rows[i][0].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			@@ -2664,64 +3228,62 @@
			{
			StuCode = "200";
			message = "数据验证成功";
			count = excelTable.Rows.Count;
			count = excelTable[0].Rows.Count;
			}
			return list;
			}
			#endregion

			#region【Excel上传数据验证,设备保养标准】
			public static List<ExcelErro> TwentyThreeData(string FileCode, out string StuCode, out string message, out int count)
			public static List<ExcelErro> Eleven_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;
			var dynamicParams = new DynamicParameters();
			List<ExcelErro> list = new List<ExcelErro>();
			List<DataTable> excelTable = new List<DataTable>();
			list = ImportExcel.ExcelToTableListErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTableList(FileCode); //获取Excel数据
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//当前Excel数据中保养标准页签中,设备保养标准编号(唯一是否有重复)
			DataTable distinct = excelTable[0].DefaultView.ToTable(true, "设备保养标准编号(唯一)");
			DataTable distinct = excelTable[0].DefaultView.ToTable(true, "*设备保养标准编号(唯一)");
			if (distinct.Rows.Count != excelTable[0].Rows.Count)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{设备保养标准编号(唯一)}";
			erro.ErrorCont = "设备保养标准页签模板:{设备保养标准编号(唯一)}有重复";
			erro.ErrorField = "{*设备保养标准编号(唯一)}";
			erro.ErrorCont = "设备保养标准页签模板:{*设备保养标准编号(唯一)}有重复";
			list.Add(erro);
			}
			//设备保养标准表是否已存在保养标准
			for (int j = 0; j < excelTable[0].Rows.Count; j++)
			{
			if (excelTable[0].Rows[j][1].ToString().Trim() != null && excelTable[0].Rows[j][1].ToString().Trim() != "")
			if (excelTable[0].Rows[j][0].ToString().Trim() != null && excelTable[0].Rows[j][0].ToString().Trim() != "")
			{
			sql = @"select * from TEqpmai_Main where code=@code";
			dynamicParams.Add("@code", excelTable[0].Rows[j][1].ToString().Trim());
			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][1].ToString().Trim() + "在数据表中已存在";
			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][1].ToString().Trim());
			DataTable ds = var_dtTable.Any() ? var_dtTable.CopyToDataTable() : excelTable[1].Clone();
			var var_dtTable = excelTable[1].AsEnumerable().Where<DataRow>(W => W["*设备保养标准编号(M)"].ToString() == excelTable[0].Rows[j][0].ToString().Trim());
			DataTable ds = var_dtTable.Any() ? var_dtTable.CopyToDataTable() : excelTable[0].Clone();
			if (ds.Rows.Count > 0)
			{
			//判断保养标准查询保养部位数据是否有重复
			DataTable distinct1 = ds.DefaultView.ToTable(true, "设备保养部位编号(唯一)");
			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][2].ToString().Trim() + " 对应{设备保养部位编号(唯一)}有重复";
			erro.ErrorField = "{*设备保养部位编号(唯一)}";
			erro.ErrorCont = "设备保养部位页签模板:{设备保养标准编号(M)}:" + excelTable[1].Rows[j][1].ToString().Trim() + " 对应{设备保养部位编号(唯一)}有重复";
			list.Add(erro);
			}
			}
			@@ -2729,8 +3291,8 @@
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{设备保养部位编号(唯一)}";
			erro.ErrorCont = "设备保养部位页签模板:{设备保养标准编号}:" + excelTable[1].Rows[j][2].ToString().Trim() + " 在设备保养标准页签模板中不存在";
			erro.ErrorField = "{*设备保养标准编号(唯一)}";
			erro.ErrorCont = "设备保养标准模板sheet1中:{设备保养标准编号(M)}:" + excelTable[1].Rows[j][0].ToString().Trim() + " 在设备保养标准模板sheet中{设备保养标准编号(唯一)}列不存在";
			list.Add(erro);
			}
			}
			@@ -2738,17 +3300,17 @@
			//当前Excel数据中点检部位页签中,设备保养部位编号(唯一)在设备保养部位表中是否存在
			for (int k = 0; k < excelTable[1].Rows.Count; k++)
			{
			if (excelTable[1].Rows[k][3].ToString().Trim() != null && excelTable[1].Rows[k][3].ToString().Trim() != "")
			if (excelTable[1].Rows[k][2].ToString().Trim() != null && excelTable[1].Rows[k][2].ToString().Trim() != "")
			{
			sql = @"select * from TEqpmai_Item where code=@code";
			dynamicParams.Add("@code", excelTable[1].Rows[k][3].ToString().Trim());
			dynamicParams.Add("@code", excelTable[1].Rows[k][2].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt.Rows.Count < 0)
			if (dt.Rows.Count <=0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{设备保养部位编号(唯一)}";
			erro.ErrorCont = "设备保养部位表:{设备保养部位编号(唯一)}字段" + excelTable[1].Rows[k][2].ToString().Trim() + "在数据表中不存在";
			erro.ErrorField = "{*设备保养部位编号(唯一)}";
			erro.ErrorCont = "设备保养部位表:{*设备保养部位编号(唯一)}字段" + excelTable[1].Rows[k][2].ToString().Trim() + "在数据表中不存在";
			list.Add(erro);
			}
			}
			@@ -2757,16 +3319,16 @@
			var dt3 = from r in excelTable[1].AsEnumerable()
			where !(
			from rr in excelTable[0].AsEnumerable()
			select rr.Field<string>("设备保养标准编号(唯一)")
			).Contains(r.Field<string>("设备保养标准编号"))
			select rr.Field<string>("*设备保养标准编号(唯一)")
			).Contains(r.Field<string>("*设备保养标准编号(M)"))
			select r;
			List<DataRow> listRow = dt3.ToList();
			if (listRow.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{设备保养标准编号}";
			erro.ErrorCont = "设备保养部位页签模板:{设备保养标准编号}字段中有值在设备保养标准页签模板:{设备保养标准编号(唯一)}中不存在";
			erro.ErrorField = "{*设备保养标准编号(M)}";
			erro.ErrorCont = "设备保养部位页签模板:{设备保养标准编号(M)}字段中有值在设备保养标准页签模板:{设备保养标准编号(唯一)}中不存在";
			list.Add(erro);
			}
			if (list.Count > 0)
			@@ -2790,58 +3352,515 @@
			}
			#endregion

			#region【Excel上传数据验证,工装清单】
			public static List<ExcelErro> TwelveData(string FileCode, out string StuCode, out string message, out int count)
			#region【Excel上传数据验证,模具清单】
			public static List<ExcelErro> TwelveData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			count = 0;
			string sql = "";
			DataTable dt;
			var dynamicParams = new DynamicParameters();
			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 TMouldInfo 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 TMouldInfo 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);
			}
			}
			}
			//模具关联产品表
			for (int j = 0; j < excelTable[1].Rows.Count; j++)
			{
			if (excelTable[1].Rows[j][1].ToString().Trim() != null && excelTable[1].Rows[j][1].ToString().Trim() != "")
			{
			sql = @"select * from TMateriel_Info where partcode=@partcode";
			dynamicParams.Add("@partcode", excelTable[1].Rows[j][1].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[j][1].ToString().Trim() + "不存在";
			list.Add(erro);
			}
			}
			}
			//判断模具关联产品表是否有数据
			if (excelTable[1].Rows.Count > 0)
			{
			//判断子表外键不存在于主表主键中的数据
			var dt3 = from r in excelTable[1].AsEnumerable()
			where !(
			from rr in excelTable[0].AsEnumerable()
			select rr.Field<string>("*模具编号(唯一)").Trim()
			).Contains(r.Field<string>("模具编码").Trim())
			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> ThirteenData(string FileCode, out string StuCode, out string message, out int count)
			#region【Excel上传数据验证,模具点检项目】
			public static List<ExcelErro> ThirteenData(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 TMouldchk_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 TMouldchk_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(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["*模具点检标准编号(M)"].ToString().Trim() == 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 = "模具点检项页签模板:{模具点检标准编号(M)}:" + excelTable[1].Rows[j][0].ToString().Trim() + " 对应{模具点检项编号(唯一)}有重复";
			list.Add(erro);
			}
			}
			else
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{*模具点检标准编号(唯一)}";
			erro.ErrorCont = "模具点检标准模板sheet1中:{模具点检标准编号(M)}:" + excelTable[1].Rows[j][0].ToString().Trim() + " 在模具点检标准模板sheet中{模具点检标准编号(唯一)}列不存在";
			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 and name=@name";
			dynamicParams.Add("@code", excelTable[1].Rows[k][2].ToString().Trim());
			dynamicParams.Add("@name", excelTable[1].Rows[k][3].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() +","+ excelTable[1].Rows[k][3].ToString().Trim() + "}在模具点检项中不存在";
			list.Add(erro);
			}
			}
			}
			//判断子表外键不存在于主表主键中的数据
			var dt3 = from r in excelTable[1].AsEnumerable()
			where !(
			from rr in excelTable[0].AsEnumerable()
			select rr.Field<string>("*模具点检标准编号(唯一)").Trim()
			).Contains(r.Field<string>("*模具点检标准编号(M)").Trim())
			select r;
			List<DataRow> listRow = dt3.ToList();
			if (listRow.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{*模具点检标准编号(M)}";
			erro.ErrorCont = "模具点检项页签模板:{模具点检标准编号(M)}字段中有值在模具点检标准页签模板:{模具点检标准编号(唯一)}中不存在";
			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["*模具保养标准编号(M)"].ToString().Trim() == 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 = "模具保养项页签模板:{模具保养标准编号(M)}:" + excelTable[1].Rows[j][0].ToString().Trim() + " 对应{模具保养项编号(唯一)}有重复";
			list.Add(erro);
			}
			}
			else
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{*模具保养标准编号(唯一)}";
			erro.ErrorCont = "模具保养标准模板sheet1中:{模具保养标准编号(M)}:" + excelTable[1].Rows[j][0].ToString().Trim() + " 在模具保养标准模板sheet中{模具保养标准编号(唯一)}列不存在";
			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 and name=@name";
			dynamicParams.Add("@code", excelTable[1].Rows[k][2].ToString().Trim());
			dynamicParams.Add("@name", excelTable[1].Rows[k][3].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() + "," + excelTable[1].Rows[k][3].ToString().Trim() + "}在模具保养项中不存在";
			list.Add(erro);
			}
			}
			}
			//判断子表外键不存在于主表主键中的数据
			var dt3 = from r in excelTable[1].AsEnumerable()
			where !(
			from rr in excelTable[0].AsEnumerable()
			select rr.Field<string>("*模具保养标准编号(唯一)").Trim()
			).Contains(r.Field<string>("*模具保养标准编号(M)").Trim())
			select r;
			List<DataRow> listRow = dt3.ToList();
			if (listRow.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{*模具保养标准编号(M)}";
			erro.ErrorCont = "模具保养项页签模板:{模具保养标准编号(M)}字段中有值在模具保养标准页签模板:{模具保养标准编号(唯一)}中不存在";
			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> FifteenData(string FileCode, out string StuCode, out string message, out int count)
			public static List<ExcelErro> FifteenData(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 TStep where stepcode=@stepcode";
			dynamicParams.Add("@stepcode", 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 TStep where stepname=@stepname";
			dynamicParams.Add("@stepname", 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
			@@ -3012,32 +4031,44 @@
			#endregion

			#region【Excel上传数据验证,缺陷定义】
			public static List<ExcelErro> EighteenData(string FileCode, out string StuCode, out string message, out int count)
			public static List<ExcelErro> EighteenData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			count = 0;
			string sql = "";
			DataTable dt;
			var dynamicParams = new DynamicParameters();
			DataTable dt;
			List<ExcelErro> list = new List<ExcelErro>();
			DataTable excelTable = new DataTable();
			list = ImportExcel.ExcelToTableErro(FileCode); //验证Excel数据必填字段是否为空、唯一字段是否重复
			excelTable = ImportExcel.ExcelToTable(FileCode); //获取Excel数据
			for (int i = 0; i < excelTable.Rows.Count; i++)
			list = ImportExcel.InportExcelToTableListErro(excelTable); //验证Excel数据必填字段是否为空、唯一字段是否重复
			//缺陷表
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			{
			if (excelTable.Rows[i][1].ToString().Trim() != null && excelTable.Rows[i][1].ToString().Trim() != "")
			if (excelTable[0].Rows[k][0].ToString().Trim() != null && excelTable[0].Rows[k][0].ToString().Trim() != "")
			{
			sql = @"select code from TDefect where code=@code";

			dynamicParams.Add("@code", excelTable.Rows[i][1].ToString().Trim());
			sql = @"select * from TDefect 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.Rows[i][1].ToString().Trim() + "已存在";
			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 TDefect 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[1].Rows[k][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			@@ -3057,7 +4088,7 @@
			{
			StuCode = "200";
			message = "数据验证成功";
			count = excelTable.Rows.Count;
			count = excelTable[0].Rows.Count;
			}
			return list;
			}
			@@ -3335,53 +4366,32 @@
			#endregion

			#region【Excel数据上传,岗位管理】
			public static string OneSubmit(string FileCode, string User, out string StuCode)
			public static string OneSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			string sql = "";
			string ZZName = "", Enable = "", WageType = "";
			DataTable dt;
			List<object> list = new List<object>();
			var dynamicParams = new DynamicParameters();
			try
			{
			list.Clear();
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			//导入角色类型
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			//导入岗位
			for (int i = 0; i < excelTable[0].Rows.Count; i++)
			{
			sql = @"insert into TRoleType(roletype_code,roletype_name,torg_code)
			values(@roletype_code,@roletype_name,@torg_code)";
			sql = @"insert into TPost(postcode,postname,status,description,lm_user,lm_date)
			values(@postcode,@postname,@status,@description,@lm_user,@lm_date)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			roletype_code = excelTable[0].Rows[k][2].ToString().Trim(),
			roletype_name = excelTable[0].Rows[k][3].ToString().Trim(),
			torg_code = excelTable[0].Rows[k][1].ToString().Trim()
			}
			});
			}
			//导入角色
			for (int i = 0; i < excelTable[1].Rows.Count; i++)
			{
			sql = @"insert into TRole(role_code,role_name,roletype_code,description,lm_user,lm_date,torg_code)
			values(@role_code,@role_name,@roletype_code,@description,@Operator,@CreateDate,@torg_code)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			role_code = excelTable[1].Rows[i][2].ToString().Trim(),
			role_name = excelTable[1].Rows[i][3].ToString().Trim(),
			roletype_code = excelTable[1].Rows[i][4].ToString().Trim(),
			description = excelTable[1].Rows[i][5].ToString().Trim(),
			Operator = User,
			CreateDate = DateTime.Now.ToString(),
			torg_code = excelTable[1].Rows[i][1].ToString().Trim()
			postcode = excelTable[0].Rows[i][0].ToString().Trim(),
			postname = excelTable[0].Rows[i][1].ToString().Trim(),
			status = excelTable[0].Rows[i][2].ToString().Trim(),
			description = excelTable[0].Rows[i][3].ToString().Trim(),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString()
			}
			});
			}
			@@ -3407,13 +4417,46 @@
			#endregion

			#region【Excel数据上传,分组管理】
			public static string TwoSubmit(string FileCode, string User, out string StuCode)
			public static string TwoSubmit(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 TGroup(usergroupcode,usergroupname,status,description,lm_user,lm_date)
			values(@usergroupcode,@usergroupname,@status,@description,@lm_user,@lm_date)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			usergroupcode = excelTable[0].Rows[i][0].ToString().Trim(),
			usergroupname = excelTable[0].Rows[i][1].ToString().Trim(),
			status = excelTable[0].Rows[i][2].ToString().Trim(),
			description = excelTable[0].Rows[i][3].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)
			{
			@@ -3491,53 +4534,58 @@
			#endregion

			#region【Excel数据上传,角色管理】
			public static string FourSubmit(string FileCode, string User, out string StuCode)
			public static string FourSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			string sql = "";
			DataTable dt;
			string sql = "", datarange = "", datapermissions = "";
			List<object> list = new List<object>();
			var dynamicParams = new DynamicParameters();
			try
			{
			list.Clear();
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			//导入往来单位表
			for (int i = 0; i < excelTable.Rows.Count; i++)
			//导入角色
			for (int i = 0; i < excelTable[0].Rows.Count; i++)
			{
			string Type = "";
			switch (excelTable.Rows[i][3].ToString().Trim())
			{
			case "供应商":
			Type = "226";
			break;
			case "客户":
			Type = "211";
			break;
			case "客户/供应商":
			Type = "228";
			break;
			default:
			break;
			}
			//if (excelTable[0].Rows[i][3].ToString().Trim() != null && excelTable[0].Rows[i][3].ToString().Trim() != "")
			//{
			// //数据范围
			// switch (excelTable[0].Rows[i][3].ToString().Trim())
			// {
			// case "全部":
			// datarange = "ALL";
			// break;
			// case "本级":
			// datarange = "LEVEL";
			// break;
			// case "本人":
			// datarange = "PERSON";
			// break;
			// case "自定义":
			// datarange = "CUSTOM";
			// datapermissions = excelTable[0].Rows[i][4].ToString().Trim();
			// break;
			// default:
			// break;
			// }
			//}

			sql = @"insert into TCustomer(code,name,type,conttacts,conttphone,addr,lm_user,lm_date)
			values(@code,@name,@type,@conttacts,@conttphone,@addr,@Operator,@CreateDate)";
			sql = @"insert into TRole(rolecode,rolename,status,datarange,datapermissions,identifying,description,lm_user,lm_date)
			values(@rolecode,@rolename,@status,@datarange,@datapermissions,@identifying,@description,@lm_user,@lm_date)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable.Rows[i][1].ToString().Trim(),
			name = excelTable.Rows[i][2].ToString().Trim(),
			type = Type,
			conttacts = excelTable.Rows[i][4].ToString().Trim(),
			conttphone = excelTable.Rows[i][5].ToString().Trim(),
			addr = excelTable.Rows[i][6].ToString().Trim(),
			Operator = User,
			CreateDate = DateTime.Now.ToString()
			rolecode = excelTable[0].Rows[i][0].ToString().Trim(),
			rolename = excelTable[0].Rows[i][1].ToString().Trim(),
			status = excelTable[0].Rows[i][2].ToString().Trim(),
			datarange = "ALL",
			datapermissions = datapermissions,
			identifying="2",
			description = excelTable[0].Rows[i][3].ToString().Trim(),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString()
			}
			});
			}
			@@ -3563,53 +4611,55 @@
			#endregion

			#region【Excel数据上传,往来单位】
			public static string FiveSubmit(string FileCode, string User, out string StuCode)
			public static string FiveSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			string sql = "";
			DataTable dt;
			List<object> list = new List<object>();
			var dynamicParams = new DynamicParameters();
			try
			{
			list.Clear();
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			//导入往来单位表
			for (int i = 0; i < excelTable.Rows.Count; i++)
			//导入往来单位类型
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			{
			string Type = "";
			switch (excelTable.Rows[i][3].ToString().Trim())
			{
			case "供应商":
			Type = "226";
			break;
			case "客户":
			Type = "211";
			break;
			case "客户/供应商":
			Type = "228";
			break;
			default:
			break;
			}

			sql = @"insert into TCustomer(code,name,type,conttacts,conttphone,addr,lm_user,lm_date)
			values(@code,@name,@type,@conttacts,@conttphone,@addr,@Operator,@CreateDate)";
			sql = @"insert into TCustomerType(code,name,idparent,lm_user,lm_date,data_sources)
			values(@code,@name,@idparent,@lm_user,@lm_date,@data_sources)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable.Rows[i][1].ToString().Trim(),
			name = excelTable.Rows[i][2].ToString().Trim(),
			type = Type,
			conttacts = excelTable.Rows[i][4].ToString().Trim(),
			conttphone = excelTable.Rows[i][5].ToString().Trim(),
			addr = excelTable.Rows[i][6].ToString().Trim(),
			Operator = User,
			CreateDate = DateTime.Now.ToString()
			code = excelTable[0].Rows[k][0].ToString().Trim(),
			name = excelTable[0].Rows[k][1].ToString().Trim(),
			idparent = excelTable[0].Rows[k][2].ToString().Trim(),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString(),
			data_sources = "MES"
			}
			});
			}
			//导入往来单位
			for (int i = 0; i < excelTable[1].Rows.Count; i++)
			{
			sql = @"insert into TCustomer(code,name,status,conttacts,conttphone,addr,customertype,lm_user,lm_date,data_sources)
			values(@code,@name,@status,@conttacts,@conttphone,@addr,@customertype,@lm_user,@lm_date,@data_sources)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable[1].Rows[i][0].ToString().Trim(),
			name = excelTable[1].Rows[i][1].ToString().Trim(),
			status = excelTable[1].Rows[i][2].ToString().Trim(),
			customertype = excelTable[1].Rows[i][3].ToString().Trim(),
			conttacts = excelTable[1].Rows[i][4].ToString().Trim(),
			conttphone = excelTable[1].Rows[i][5].ToString().Trim(),
			addr = excelTable[1].Rows[i][6].ToString().Trim(),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString(),
			data_sources = "MES"
			}
			});
			}
			@@ -3635,7 +4685,7 @@
			#endregion

			#region【Excel数据上传,仓库设置】
			public static string SixSubmit(string FileCode, string User, out string StuCode)
			public static string SixSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			@@ -3645,42 +4695,24 @@
			try
			{
			list.Clear();
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			//导入仓库
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			for (int i = 0; i < excelTable[0].Rows.Count; i++)
			{
			sql = @"insert into T_Sec_Stck(code,name,description,lm_user,lm_date)
			values(@code,@name,@description,@Operator,@CreateDate)";
			sql = @"insert into TSecStck(code,name,status,ishasPosition,description,lm_user,lm_date,data_sources)
			values(@code,@name,@status,@ishasPosition,@description,@lm_user,@lm_date,@data_sources)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable[0].Rows[k][1].ToString().Trim(),
			name = excelTable[0].Rows[k][2].ToString().Trim(),
			description = excelTable[0].Rows[k][3].ToString().Trim(),
			CreateDate = DateTime.Now.ToString(),
			Operator = User
			}
			});
			}
			//导入库位
			for (int i = 0; i < excelTable[1].Rows.Count; i++)
			{
			sql = @"insert into T_Sec_Loca(code,name,description,stock_code,lm_user,lm_date)
			values(@code,@name,@description,@stock_code,@Operator,@CreateDate)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable[1].Rows[i][1].ToString().Trim(),
			name = excelTable[1].Rows[i][2].ToString().Trim(),
			stock_code = excelTable[1].Rows[i][3].ToString().Trim(),
			description = excelTable[1].Rows[i][4].ToString().Trim(),
			Operator = User,
			CreateDate = DateTime.Now.ToString()
			code = excelTable[0].Rows[i][0].ToString().Trim(),
			name = excelTable[0].Rows[i][1].ToString().Trim(),
			status = excelTable[0].Rows[i][2].ToString().Trim(),
			ishasPosition = excelTable[0].Rows[i][3].ToString().Trim(),
			description = excelTable[0].Rows[i][4].ToString().Trim(),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString(),
			data_sources = "MES"
			}
			});
			}
			@@ -3706,13 +4738,49 @@
			#endregion

			#region【Excel数据上传,库位设置】
			public static string SevenSubmit(string FileCode, string User, out string StuCode)
			public static string SevenSubmit(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 TSecLoca(code,name,idwarehouse,idparent,status,description,lm_user,lm_date,data_sources)
			values(@code,@name,@idwarehouse,@idparent,@status,@description,@lm_user,@lm_date,@data_sources)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable[0].Rows[i][0].ToString().Trim(),
			name = excelTable[0].Rows[i][1].ToString().Trim(),
			idwarehouse = excelTable[0].Rows[i][2].ToString().Trim(),
			idparent = excelTable[0].Rows[i][3].ToString().Trim(),
			status = excelTable[0].Rows[i][4].ToString().Trim(),
			description = excelTable[0].Rows[i][5].ToString().Trim(),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString(),
			data_sources = "MES"
			}
			});
			}
			bool aa = DapperHelper.DoTransaction(list);
			if (aa)
			{
			StuCode = "200";
			message = "导入成功！";
			}
			else
			{
			StuCode = "300";
			message = "导入失败！";
			}
			}
			catch (Exception e)
			{
			@@ -3724,13 +4792,107 @@
			#endregion

			#region【Excel数据上传,存货档案】
			public static string EightSubmit(string FileCode, string User, out string StuCode)
			public static string EightSubmit(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 TMateriel_Class(code,name,idparent,lm_user,lm_date,data_sources)
			values(@code,@name,@idparent,@lm_user,@lm_date,@data_sources)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable[0].Rows[k][0].ToString().Trim(),
			name = excelTable[0].Rows[k][1].ToString().Trim(),
			idparent = excelTable[0].Rows[k][2].ToString().Trim(),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString(),
			data_sources = "MES"
			}
			});
			}
			//导入存货档案
			for (int i = 0; i < excelTable[1].Rows.Count; i++)
			{
			string idunitgroup="", idunit = "", idnounit = "";
			int isSingleUnit = 0;
			if (excelTable[1].Rows[i][5].ToString().Trim() == "S")
			{
			isSingleUnit = 1;
			sql = @"select * from TUnit where name=@name and isSingleUnit='1'";
			dynamicParams.Add("@name", excelTable[1].Rows[i][6].ToString().Trim());
			var dt = DapperHelper.selectdata(sql, dynamicParams);
			idunit = dt.Rows[0]["code"].ToString();
			}
			if (excelTable[1].Rows[i][5].ToString().Trim() == "M")
			{
			sql = @"select T.code,T.name,T.isMainUnit from TUnitGroup G
			inner join TUnit T on G.code=T.idunitgroup
			where G.name=@name";
			dynamicParams.Add("@name", excelTable[1].Rows[i][6].ToString().Trim());
			var dt = DapperHelper.selectdata(sql, dynamicParams);
			idunitgroup = dt.Rows[0]["groupcode"].ToString();
			idunit = dt.AsEnumerable().Where(row => row.Field<string>("isMainUnit") =="1").Select(row => row.Field<string>("code")).FirstOrDefault();
			idnounit = dt.AsEnumerable().Where(row => row.Field<string>("isMainUnit") == "0").Select(row => row.Field<string>("code")).FirstOrDefault();
			}

			sql = @"insert into TMateriel_Info(partcode,partname,partspec,idunit,idunitgroup,isSingleUnit,idSubUnitByReport,idUnitByStock,
			idUnitByPurchase,idUnitBySale,idunitbymanufacture,idinventoryclass,isPurchase,isSale,isMadeSelf,isMaterial,isMadeRequest,
			idwarehouse,status,lm_user,lm_date,data_sources)
			values(@partcode,@partname,@partspec,@idunit,@idunitgroup,@isSingleUnit,@idSubUnitByReport,@idUnitByStock,
			@idUnitByPurchase,@idUnitBySale,@idunitbymanufacture,@idinventoryclass,@isPurchase,@isSale,@isMadeSelf,@isMaterial,@isMadeRequest,
			@idwarehouse,@status,@lm_user,@lm_date,@data_sources)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			partcode = excelTable[1].Rows[i][0].ToString().Trim(),
			partname = excelTable[1].Rows[i][1].ToString().Trim(),
			partspec = excelTable[1].Rows[i][2].ToString().Trim(),
			idunit = idunit,
			idunitgroup = idunitgroup,
			isSingleUnit = isSingleUnit,
			idSubUnitByReport = idnounit,
			idUnitByStock = idunit,
			idUnitByPurchase = idunit,
			idUnitBySale = idunit,
			idunitbymanufacture = idunit,
			idinventoryclass = excelTable[1].Rows[i][3].ToString().Trim(),
			isPurchase = excelTable[1].Rows[i][8].ToString().Trim(),
			isSale = excelTable[1].Rows[i][9].ToString().Trim(),
			isMadeSelf = excelTable[1].Rows[i][10].ToString().Trim(),
			isMaterial = excelTable[1].Rows[i][11].ToString().Trim(),
			isMadeRequest = excelTable[1].Rows[i][12].ToString().Trim(),
			idwarehouse = excelTable[1].Rows[i][7].ToString().Trim(),
			status = excelTable[1].Rows[i][4].ToString().Trim(),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString(),
			data_sources = "MES"
			}
			});
			}
			bool aa = DapperHelper.DoTransaction(list);
			if (aa)
			{
			StuCode = "200";
			message = "导入成功！";
			}
			else
			{
			StuCode = "300";
			message = "导入失败！";
			}
			}
			catch (Exception e)
			{
			@@ -3742,42 +4904,52 @@
			#endregion

			#region【Excel数据上传,设备清单】
			public static string NineSubmit(string FileCode, string User, out string StuCode)
			public static string NineSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = ""; StuCode = "";
			string message = "";
			StuCode = "";
			string sql = "";
			List<object> list = new List<object>();
			var dynamicParams = new DynamicParameters();
			try
			{
			list.Clear();
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			//导入设备清单
			for (int k = 0; k < excelTable.Rows.Count; k++)
			//导入设备类型
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			{
			sql = @"select * from TEqpInfo where code=@eqp_code";
			dynamicParams.Add("@eqp_code", excelTable.Rows[k][1].ToString().Trim());
			DataTable dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt.Rows.Count > 0)
			{
			continue;
			}
			sql = @"insert into TEqpInfo(code,name,wksp_code,input_date,operation_ration,enable,opc_uom,lm_user,lm_date)
			values(@devicecode,@devicename,@workshop,@importdate,@ratio,@status,@uom,@lm_user,@lm_date)";
			sql = @"insert into TEqpType(code,name,lm_user,lm_date,remark)
			values(@code,@name,@lm_user,@lm_date,@remark)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			devicecode = excelTable.Rows[k][1].ToString().Trim(),
			devicename = excelTable.Rows[k][2].ToString().Trim(),
			workshop = excelTable.Rows[k][4].ToString().Trim(),
			importdate = excelTable.Rows[k][3].ToString().Trim(),
			ratio = excelTable.Rows[k][6].ToString().Trim(),
			status = excelTable.Rows[k][5].ToString().Trim(),
			uom = "台",
			lm_user = User,
			code = excelTable[0].Rows[k][0].ToString().Trim(),
			name = excelTable[0].Rows[k][1].ToString().Trim(),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString(),
			remark = excelTable[0].Rows[k][2].ToString().Trim()
			}
			});
			}
			//导入设备
			for (int i = 0; i < excelTable[1].Rows.Count; i++)
			{
			sql = @"insert into TEqpInfo(code,name,torg_code,eqptype_code,operation_ration,enable,opc_uom,lm_user,lm_date)
			values(@code,@name,@torg_code,@eqptype_code,@operation_ration,@enable,@opc_uom,@lm_user,@lm_date)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable[1].Rows[i][0].ToString().Trim(),
			name = excelTable[1].Rows[i][1].ToString().Trim(),
			torg_code = excelTable[1].Rows[i][2].ToString().Trim(),
			eqptype_code = excelTable[1].Rows[i][3].ToString().Trim(),
			operation_ration = "100",
			enable = excelTable[1].Rows[i][4].ToString().Trim(),
			opc_uom = "台",
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString()
			}
			});
			@@ -3804,7 +4976,7 @@
			#endregion

			#region【Excel数据上传,设备点检项目】
			public static string TenSubmit(string FileCode, string User, out string StuCode)
			public static string TenSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			@@ -3814,13 +4986,11 @@
			try
			{
			list.Clear();
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			//导入设备点检项目表
			for (int i = 0; i < excelTable.Rows.Count; i++)
			for (int i = 0; i < excelTable[0].Rows.Count; i++)
			{
			string Type = "", IsScan = "";
			switch (excelTable.Rows[i][3].ToString().Trim())
			switch (excelTable[0].Rows[i][2].ToString().Trim())
			{
			case "年":
			Type = "Y";
			@@ -3840,7 +5010,7 @@
			default:
			break;
			}
			switch (excelTable.Rows[i][4].ToString().Trim())
			switch (excelTable[0].Rows[i][3].ToString().Trim())
			{
			case "是":
			IsScan = "Y";
			@@ -3858,12 +5028,12 @@
			str = sql,
			parm = new
			{
			code = excelTable.Rows[i][1].ToString().Trim(),
			name = excelTable.Rows[i][2].ToString().Trim(),
			descr = excelTable.Rows[i][5].ToString().Trim(),
			code = excelTable[0].Rows[i][0].ToString().Trim(),
			name = excelTable[0].Rows[i][1].ToString().Trim(),
			descr = excelTable[0].Rows[i][4].ToString().Trim(),
			isscan = IsScan,
			cycle = Type,
			Operator = User,
			Operator = us.usercode,
			CreateDate = DateTime.Now.ToString()
			}
			});
			@@ -3890,7 +5060,7 @@
			#endregion

			#region【Excel数据上传,设备点检标准】
			public static string TwentyTwoSubmit(string FileCode, string User, out string StuCode)
			public static string Ten_oneSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			@@ -3900,8 +5070,6 @@
			try
			{
			list.Clear();
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			//导入设备点检标准主表
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			{
			@@ -3912,12 +5080,12 @@
			str = sql,
			parm = new
			{
			code = excelTable[0].Rows[k][1].ToString().Trim(),
			name = excelTable[0].Rows[k][2].ToString().Trim(),
			iscontr = excelTable[0].Rows[k][3].ToString().Trim(),
			description = excelTable[0].Rows[k][4].ToString().Trim(),
			code = excelTable[0].Rows[k][0].ToString().Trim(),
			name = excelTable[0].Rows[k][1].ToString().Trim(),
			iscontr = excelTable[0].Rows[k][2].ToString().Trim(),
			description = excelTable[0].Rows[k][3].ToString().Trim(),
			CreateDate = DateTime.Now.ToString(),
			Operator = User
			Operator = us.usercode
			}
			});
			}
			@@ -3925,7 +5093,7 @@
			for (int i = 0; i < excelTable[1].Rows.Count; i++)
			{
			string Type = "";
			switch (excelTable[1].Rows[i][7].ToString().Trim())
			switch (excelTable[1].Rows[i][6].ToString().Trim())
			{
			case "日":
			Type = "D";
			@@ -3941,13 +5109,13 @@
			parm = new
			{
			seq = excelTable[1].Rows[i][1].ToString().Trim(),
			code = excelTable[1].Rows[i][3].ToString().Trim(),
			name = excelTable[1].Rows[i][4].ToString().Trim(),
			eqpchk_main_code = excelTable[1].Rows[i][2].ToString().Trim(),
			description = excelTable[1].Rows[i][5].ToString().Trim(),
			isscan = excelTable[1].Rows[i][6].ToString().Trim(),
			code = excelTable[1].Rows[i][2].ToString().Trim(),
			name = excelTable[1].Rows[i][3].ToString().Trim(),
			eqpchk_main_code = excelTable[1].Rows[i][0].ToString().Trim(),
			description = excelTable[1].Rows[i][4].ToString().Trim(),
			isscan = excelTable[1].Rows[i][5].ToString().Trim(),
			cycle = Type,
			Operator = User,
			Operator = us.usercode,
			CreateDate = DateTime.Now.ToString()
			}
			});
			@@ -3974,7 +5142,7 @@
			#endregion

			#region【Excel数据上传,设备保养项目】
			public static string ElevenSubmit(string FileCode, string User, out string StuCode)
			public static string ElevenSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			@@ -3984,33 +5152,11 @@
			try
			{
			list.Clear();
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			//导入设备点检项目表
			for (int i = 0; i < excelTable.Rows.Count; i++)
			for (int i = 0; i < excelTable[0].Rows.Count; i++)
			{
			string Type = "", IsScan = "";
			//switch (excelTable.Rows[i][3].ToString().Trim())
			//{
			// case "年":
			// Type = "Y";
			// break;
			// case "季":
			// Type = "S";
			// break;
			// case "月":
			// Type = "M";
			// break;
			// case "周":
			// Type = "W";
			// break;
			// case "日":
			// Type = "D";
			// break;
			// default:
			// break;
			//}
			switch (excelTable.Rows[i][3].ToString().Trim())
			string IsScan = "";
			switch (excelTable[0].Rows[i][2].ToString().Trim())
			{
			case "是":
			IsScan = "Y";
			@@ -4028,12 +5174,12 @@
			str = sql,
			parm = new
			{
			code = excelTable.Rows[i][1].ToString().Trim(),
			name = excelTable.Rows[i][2].ToString().Trim(),
			descr = excelTable.Rows[i][4].ToString().Trim(),
			code = excelTable[0].Rows[i][0].ToString().Trim(),
			name = excelTable[0].Rows[i][1].ToString().Trim(),
			descr = excelTable[0].Rows[i][3].ToString().Trim(),
			isscan = IsScan,
			cycle = "",
			Operator = User,
			Operator = us.usercode,
			CreateDate = DateTime.Now.ToString()
			}
			});
			@@ -4060,7 +5206,7 @@
			#endregion

			#region【Excel数据上传,设备保养标准】
			public static string TwentyThreeSubmit(string FileCode, string User, out string StuCode)
			public static string Eleven_oneSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			@@ -4070,13 +5216,11 @@
			try
			{
			list.Clear();
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			//导入设备保养标准主表
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			{
			string Type = "";
			switch (excelTable[0].Rows[k][3].ToString().Trim())
			switch (excelTable[0].Rows[k][2].ToString().Trim())
			{
			case "年":
			Type = "Y";
			@@ -4100,12 +5244,12 @@
			str = sql,
			parm = new
			{
			code = excelTable[0].Rows[k][1].ToString().Trim(),
			name = excelTable[0].Rows[k][2].ToString().Trim(),
			code = excelTable[0].Rows[k][0].ToString().Trim(),
			name = excelTable[0].Rows[k][1].ToString().Trim(),
			main_cycle = Type,
			description = excelTable[0].Rows[k][4].ToString().Trim(),
			description = excelTable[0].Rows[k][3].ToString().Trim(),
			CreateDate = DateTime.Now.ToString(),
			Operator = User
			Operator = us.usercode
			}
			});
			}
			@@ -4120,12 +5264,12 @@
			parm = new
			{
			seq = excelTable[1].Rows[i][1].ToString().Trim(),
			code = excelTable[1].Rows[i][3].ToString().Trim(),
			name = excelTable[1].Rows[i][4].ToString().Trim(),
			eapmai_code = excelTable[1].Rows[i][2].ToString().Trim(),
			description = excelTable[1].Rows[i][5].ToString().Trim(),
			isscan = excelTable[1].Rows[i][6].ToString().Trim(),
			Operator = User,
			code = excelTable[1].Rows[i][2].ToString().Trim(),
			name = excelTable[1].Rows[i][3].ToString().Trim(),
			eapmai_code = excelTable[1].Rows[i][0].ToString().Trim(),
			description = excelTable[1].Rows[i][4].ToString().Trim(),
			isscan = excelTable[1].Rows[i][5].ToString().Trim(),
			Operator = us.usercode,
			CreateDate = DateTime.Now.ToString()
			}
			});
			@@ -4151,14 +5295,66 @@
			}
			#endregion

			#region【Excel数据上传,工装清单】
			public static string TwelveSubmit(string FileCode, string User, out string StuCode)
			#region【Excel数据上传,模具清单】
			public static string TwelveSubmit(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 TMouldInfo(code,name,spec,status,surp_life,resi_life,lm_user,lm_date)
			values(@code,@name,@spec,@status,@usestatus,@surp_life,@resi_life,@lm_user,@lm_date)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable[0].Rows[k][0].ToString().Trim(),
			name = excelTable[0].Rows[k][1].ToString().Trim(),
			spec = excelTable[0].Rows[k][2].ToString().Trim(),
			status = excelTable[0].Rows[k][3].ToString().Trim(),
			surp_life =decimal.Parse(excelTable[0].Rows[k][4].ToString().Trim()==""?"0": excelTable[0].Rows[k][4].ToString().Trim()),
			resi_life = decimal.Parse(excelTable[0].Rows[k][5].ToString().Trim()==""?"0":excelTable[0].Rows[k][5].ToString().Trim()),
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString()
			}
			});
			}
			//写入模具关联产品表
			for (int i = 0; i < excelTable[1].Rows.Count; i++)
			{
			sql = @"insert into TMouldInfoPart(mouldcode,partcode,lm_user,lm_date)
			values(@mouldcode,@partcode,@lm_user,@lm_date)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			mouldcode = excelTable[1].Rows[i][0].ToString().Trim(),
			partcode = excelTable[1].Rows[i][1].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)
			{
			@@ -4169,14 +5365,46 @@
			}
			#endregion

			#region【Excel数据上传,工装点检】
			public static string ThirteenSubmit(string FileCode, string User, out string StuCode)
			#region【Excel数据上传,模具点检项目】
			public static string ThirteenSubmit(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 TMouldchk_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)
			{
			@@ -4187,14 +5415,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)
			{
			@@ -4206,13 +5606,47 @@
			#endregion

			#region【Excel数据上传,工序定义】
			public static string FifteenSubmit(string FileCode, string User, out string StuCode)
			public static string FifteenSubmit(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 TStep(stepcode,stepname,enable,descr,flwtype,lm_user,lm_date)
			values(@stepcode,@stepname,@enable,@descr,@flwtype,@lm_user,@lm_date)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			stepcode = excelTable[0].Rows[i][0].ToString().Trim(),
			stepname = excelTable[0].Rows[i][1].ToString().Trim(),
			enable = excelTable[0].Rows[i][3].ToString().Trim(),
			descr = excelTable[0].Rows[i][4].ToString().Trim(),
			flwtype = 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)
			{
			@@ -4422,34 +5856,32 @@
			#endregion

			#region【Excel数据上传,缺陷定义】
			public static string EighteenSubmit(string FileCode, string User, out string StuCode)
			public static string EighteenSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			string sql = "";
			DataTable dt;
			List<object> list = new List<object>();
			var dynamicParams = new DynamicParameters();
			try
			{
			list.Clear();
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			//导入往来单位表
			for (int i = 0; i < excelTable.Rows.Count; i++)
			//导入缺陷
			for (int i = 0; i < excelTable[0].Rows.Count; i++)
			{
			sql = @"insert into TDefect(code,name,descr,lm_user,lm_date)
			values(@code,@name,@descr,@Operator,@CreateDate)";
			sql = @"insert into TDefect(code,name,description,is_step,lm_user,lm_date)
			values(@code,@name,@description,@is_step,@lm_user,@lm_date)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			code = excelTable.Rows[i][1].ToString().Trim(),
			name = excelTable.Rows[i][2].ToString().Trim(),
			descr = excelTable.Rows[i][3].ToString().Trim(),
			Operator = User,
			CreateDate = DateTime.Now.ToString()
			code = excelTable[0].Rows[i][0].ToString().Trim(),
			name = excelTable[0].Rows[i][1].ToString().Trim(),
			description = excelTable[0].Rows[i][2].ToString().Trim(),
			is_step="N",
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString()
			}
			});
			}