JLApi.git - Gitblit

			@@ -13,120 +13,398 @@
			public static ToMessage mes = new ToMessage(); //定义全局返回信息对象

			#region【Excel模板上传验证】
			#region【Excel模板上传验证,用户清单模板】
			public static string Two(string FileCode, out string code)

			#region【Excel模板上传验证,组织架构模板】
			public static string Zerro(string FileCode, out string code)
			{
			string Message = "";
			code = "";
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			if (excelTable.Count != 4)

			return Message;
			}
			#endregion

			#region【Excel模板上传验证,岗位管理模板】
			public static string One(List<DataTable> excelTable, out string code)
			{
			string Message = "";
			code = "";
			if (excelTable.Count != 1)
			{
			code = "300";
			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

			#region【Excel模板上传验证,班组管理模板】
			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

			#region【Excel模板上传验证,人员管理模板】
			public static string Three(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 != 10)
			{
			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[0].Columns[6].ColumnName != "*所属组织编码")
			{
			code = "301";
			Message = "用户清单模板：表头信息不符合规范,第7列应为{*所属组织编码}";
			return Message;
			}
			else if (excelTable[0].Columns[7].ColumnName != "所属岗位编码")
			{
			code = "301";
			Message = "用户清单模板：表头信息不符合规范,第8列应为{所属岗位编码}";
			return Message;
			}
			else if (excelTable[0].Columns[8].ColumnName != "所属角色编码")
			{
			code = "301";
			Message = "用户清单模板：表头信息不符合规范,第9列应为{所属角色编码}";
			return Message;
			}
			else if (excelTable[0].Columns[9].ColumnName != "所属班组编码")
			{
			code = "301";
			Message = "用户清单模板：表头信息不符合规范,第10列应为{所属班组编码}";
			return Message;
			}
			else
			{
			code = "200";
			Message = "模板检验通过";
			}
			return Message;
			}
			#endregion

			#region【Excel模板上传验证,角色管单模板】
			public static string Four(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

			#region【Excel模板上传验证,往来单位模板】
			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(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 != 5)
			{
			code = "300";
			Message = "用户班组模板不符合规范,请检查列名字段数";
			code = "301";
			Message = "仓库设置模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[1].Columns.Count != 10)
			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 = "用户班组模板：表头信息不符合规范,第2列应为{班组编号(唯一)}";
			code = "301";
			Message = "仓库设置模板：表头信息不符合规范,第4列应为{*库位管理}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "班组名称")
			else if (excelTable[0].Columns[4].ColumnName != "描述")
			{
			code = "300";
			Message = "用户班组模板：表头信息不符合规范,第3列应为{班组名称}";
			return Message;
			}
			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列应为{密码}";
			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列应为{邮箱}";
			return Message;
			}
			else if (excelTable[1].Columns[7].ColumnName != "组织编码")
			{
			code = "300";
			Message = "用户清单模板：表头信息不符合规范,第8列应为{组织编码}";
			return Message;
			}
			else if (excelTable[1].Columns[8].ColumnName != "工资类型")
			{
			code = "300";
			Message = "用户清单模板：表头信息不符合规范,第9列应为{工资类型}";
			return Message;
			}
			else if (excelTable[1].Columns[9].ColumnName != "用户组编码")
			{
			code = "300";
			Message = "用户清单模板：表头信息不符合规范,第10列应为{用户组编码}";
			code = "301";
			Message = "仓库设置模板：表头信息不符合规范,第5列应为{描述}";
			return Message;
			}
			else
			@@ -138,363 +416,59 @@
			}
			#endregion

			#region【Excel模板上传验证,角色权限模板】
			public static string One(string FileCode, out string code)
			#region【Excel模板上传验证,库位设置模板】
			public static string Seven(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 != 6)
			{
			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列应为{角色类型编号(唯一)}";
			code = "301";
			Message = "库位设置模板：表头信息不符合规范,第4列应为{上级库位编码}";
			return Message;
			}
			else if (excelTable[0].Columns[3].ColumnName != "角色类型名称")
			else if (excelTable[0].Columns[4].ColumnName != "*状态")
			{
			code = "300";
			Message = "角色类型模板：表头信息不符合规范,第3列应为{角色类型名称}";
			code = "301";
			Message = "库位设置模板：表头信息不符合规范,第5列应为{*状态}";
			return Message;
			}
			else if (excelTable[1].Columns[0].ColumnName != "序号")
			else if (excelTable[0].Columns[5].ColumnName != "描述")
			{
			code = "300";
			Message = "角色清单模板：表头信息不符合规范,第1列应为{序号}";
			code = "301";
			Message = "库位设置模板：表头信息不符合规范,第6列应为{描述}";
			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列应为{角色描述}";
			return Message;
			}
			else
			{
			code = "200";
			Message = "模板检验通过";
			}
			return Message;
			}
			#endregion

			#region【Excel模板上传验证,工位清单模板】
			public static string Three(string FileCode, out string code)
			{
			string Message = "";
			code = "";
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			if (excelTable.Columns.Count != 9)
			{
			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 if (excelTable.Columns[7].ColumnName != "数采标识1")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable.Columns[8].ColumnName != "数采标识2")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else
			{
			code = "200";
			Message = "模板检验通过";
			}
			return Message;
			}
			#endregion

			#region【Excel模板上传验证,往来单位清单模板】
			public static string Four(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数";
			return Message;

			}
			else if (excelTable[0].Columns.Count != 7)
			{
			code = "300";
			Message = "往来单位模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			{
			code = "300";
			Message = "往来单位模板不符合规范：表头信息不符合规范,第1列应为{序号}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "往来单位编号(唯一)")
			{
			code = "300";
			Message = "往来单位模板不符合规范：表头信息不符合规范,第2列应为{往来单位编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "往来单位名称")
			{
			code = "300";
			Message = "往来单位模板不符合规范：表头信息不符合规范,第3列应为{往来单位名称}";
			return Message;
			}
			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列应为{地址}";
			return Message;
			}
			else
			{
			code = "200";
			Message = "模板检验通过";
			}
			return Message;
			}
			#endregion

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

			}
			else if (excelTable[0].Columns.Count != 4)
			{
			code = "300";
			Message = "仓库清单模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[1].Columns.Count != 5)
			{
			code = "300";
			Message = "库位清单模板不符合规范,请检查列名字段数";
			return Message;
			}
			else if (excelTable[0].Columns[0].ColumnName != "序号")
			{
			code = "300";
			Message = "仓库清单模板：表头信息不符合规范,第1列应为{序号}";
			return Message;
			}
			else if (excelTable[0].Columns[1].ColumnName != "仓库编号(唯一)")
			{
			code = "300";
			Message = "仓库清单模板：表头信息不符合规范,第2列应为{仓库编号(唯一)}";
			return Message;
			}
			else if (excelTable[0].Columns[2].ColumnName != "仓库名称")
			{
			code = "300";
			Message = "仓库清单模板：表头信息不符合规范,第3列应为{仓库名称}";
			return Message;
			}
			else if (excelTable[0].Columns[3].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列应为{库位描述}";
			return Message;
			}
			else
			{
			code = "200";
			Message = "模板检验通过";
			}
			return Message;
			}
			#endregion

			#region【Excel模板上传验证,容器定义模板】
			public static string Seven(string FileCode, out string code)
			{
			string Message = "";
			code = "";
			DataTable excelTable = new DataTable();
			excelTable = ImportExcel.ExcelToTable(FileCode);
			if (excelTable.Columns.Count != 5)
			{
			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 != "容器自重（KG）")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else if (excelTable.Columns[4].ColumnName != "容器类型")
			{
			code = "300";
			Message = "模板不符合规范,请检查列名";
			}
			else
			{
			@@ -506,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
			{
			@@ -582,56 +609,82 @@
			#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 != 6)
			{
			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 if (excelTable[1].Columns[5].ColumnName != "*状态")
			{
			code = "301";
			Message = "设备清单模板：表头信息不符合规范,第6列应为{*状态}";
			return Message;
			}
			else
			{
			@@ -1561,47 +1614,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
			@@ -1854,8 +1899,8 @@
			#endregion

			#region【Excel上传数据验证】
			#region【Excel上传数据验证,用户角色】
			public static List<ExcelErro> TwoData(string FileCode, out string StuCode, out string message, out int count)
			#region【Excel上传数据验证,组织架构】
			public static List<ExcelErro> ZerroData(string savePath, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			@@ -1864,317 +1909,292 @@
			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++)

			if (list.Count > 0)
			{
			if (excelTable[0].Rows[j][2].ToString().Trim() != null && excelTable[0].Rows[j][2].ToString().Trim() != "")
			int index = 0;
			foreach (ExcelErro item in list)
			{
			sql = @"select * from TGroup where group_code=@group_code";
			dynamicParams.Add("@group_code", excelTable[0].Rows[j][2].ToString().Trim());
			index++;
			item.Seq = index.ToString();
			}
			StuCode = "301";
			message = "数据验证失败";
			}
			else
			{
			StuCode = "200";
			message = "数据验证成功";
			}
			return list;
			}
			#endregion

			#region【Excel上传数据验证,岗位管理】
			public static List<ExcelErro> 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 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 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);
			}
			}
			if (excelTable[0].Rows[k][1].ToString().Trim() != null && excelTable[0].Rows[k][1].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[0].Rows[k][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			}
			//子表
			for (int k = 0; k < excelTable[1].Rows.Count; k++)
			if (list.Count > 0)
			{
			if (excelTable[1].Rows[k][1].ToString().Trim() != null && excelTable[1].Rows[k][1].ToString().Trim() != "")
			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> 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

			#region【Excel上传数据验证,人员管理】
			public static List<ExcelErro> ThreeData(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 TUser where usercode=@usercode";
			dynamicParams.Add("@usercode", excelTable[1].Rows[k][1].ToString().Trim());
			dynamicParams.Add("@usercode", 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[1].Rows[k][1].ToString().Trim() + "已存在";
			erro.RoeNumber = (k + 1).ToString();
			erro.ErrorField = "*用户编码(唯一)";
			erro.ErrorCont = "用户表:*用户编码(唯一)字段" + excelTable[0].Rows[k][0].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[1].Rows[k][7].ToString().Trim() != null && excelTable[1].Rows[k][7].ToString().Trim() != "")
			if (excelTable[0].Rows[k][1].ToString().Trim() != null && excelTable[0].Rows[k][1].ToString().Trim() != "")
			{
			sql = @"select * from TOrganization where org_code=@org_code";
			dynamicParams.Add("@org_code", excelTable[1].Rows[k][7].ToString().Trim());
			sql = @"select * from TUser where username=@username";
			dynamicParams.Add("@username", excelTable[0].Rows[k][1].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt.Rows.Count > 0)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = (k + 1).ToString();
			erro.ErrorField = "*用户名称";
			erro.ErrorCont = "用户表:*用户名称字段" + excelTable[0].Rows[k][1].ToString().Trim() + "已存在";
			list.Add(erro);
			}
			}
			if (excelTable[0].Rows[k][6].ToString().Trim() != null && excelTable[0].Rows[k][6].ToString().Trim() != "")
			{
			sql = @"select * from TOrganization where torg_code=@torg_code";
			dynamicParams.Add("@torg_code", excelTable[0].Rows[k][6].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][7].ToString().Trim() + "不存在";
			erro.RoeNumber = (k + 1).ToString();
			erro.ErrorField = "*组织编码";
			erro.ErrorCont = "用户表:*组织编码字段" + excelTable[0].Rows[k][6].ToString().Trim() + "不存在";
			list.Add(erro);
			}
			}
			if (excelTable[1].Rows[k][9].ToString().Trim() != null && excelTable[1].Rows[k][9].ToString().Trim() != "")
			if (excelTable[0].Rows[k][7].ToString().Trim() != null && excelTable[0].Rows[k][7].ToString().Trim() != "")
			{
			sql = @"select torg_code from TGroup where group_code=@group_code";
			dynamicParams.Add("@group_code", excelTable[1].Rows[k][9].ToString().Trim());
			string[] postcode = Array.ConvertAll<string, string>(excelTable[0].Rows[k][7].ToString().Trim().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries), s => s.ToString()); //string分割转string[]
			sql = @"select postcode from TPost where postcode in @postcode";
			dynamicParams.Add("@postcode", postcode);
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt != null && dt.Rows.Count > 0)
			{
			if (dt.Rows[0]["torg_code"].ToString() != excelTable[1].Rows[k][7].ToString().Trim())
			string[] values = excelTable[0].Rows[k][7].ToString().Trim().Split(',');
			var unmatchedValues = values.Except(dt.AsEnumerable().Select(row => row.Field<string>("postcode")));
			foreach (var value in unmatchedValues)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{用户组编码}";
			erro.ErrorCont = "用户表:{用户组编码}字段" + excelTable[1].Rows[k][9].ToString().Trim() + " 不是组织编码:" + excelTable[1].Rows[k][7].ToString().Trim() + "下的用户组";
			erro.RoeNumber = (k + 1).ToString();
			erro.ErrorField = "{所属岗位编码}";
			erro.ErrorCont = "用户表:{所属岗位编码}字段" + value + " 不是有效的岗位编码";
			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)
			{
			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> OneData(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数据
			//主表
			for (int j = 0; j < excelTable[0].Rows.Count; j++)
			{
			if (excelTable[1].Rows[j][1].ToString().Trim() != null && excelTable[1].Rows[j][1].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)
			else
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{组织编码}";
			erro.ErrorCont = "角色类型表:{组织编码}字段" + excelTable[1].Rows[j][1].ToString().Trim() + "不存在";
			erro.RoeNumber = (k + 1).ToString();
			erro.ErrorField = "{所属岗位编码}";
			erro.ErrorCont = "用户表:{所属岗位编码}字段" + excelTable[0].Rows[k][7].ToString().Trim() + " 不是有效的岗位编码";
			list.Add(erro);
			}
			}
			if (excelTable[0].Rows[j][2].ToString().Trim() != null && excelTable[0].Rows[j][2].ToString().Trim() != "")
			if (excelTable[0].Rows[k][8].ToString().Trim() != null && excelTable[0].Rows[k][8].ToString().Trim() != "")
			{
			sql = @"select * from TRoleType where roletype_code=@roletype_code";
			dynamicParams.Add("@roletype_code", excelTable[0].Rows[j][2].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() + "已存在";
			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() != "")
			{
			sql = @"select * from TRole where role_code=@role_code";
			dynamicParams.Add("@role_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);
			}
			}
			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());
			string[] rolecode = Array.ConvertAll<string, string>(excelTable[0].Rows[k][8].ToString().Trim().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries), s => s.ToString()); //string分割转string[]
			sql = @"select rolecode from TRole where rolecode in @rolecode";
			dynamicParams.Add("@rolecode", rolecode);
			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())
			string[] values = excelTable[0].Rows[k][8].ToString().Trim().Split(',');
			var unmatchedValues = values.Except(dt.AsEnumerable().Select(row => row.Field<string>("rolecode")));
			foreach (var value in unmatchedValues)
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{角色类型编码}";
			erro.ErrorCont = "角色表:{角色类型编码}字段" + excelTable[1].Rows[k][4].ToString().Trim() + " 不是组织编码:" + excelTable[1].Rows[k][1].ToString().Trim() + "下的角色组";
			erro.RoeNumber = (k + 1).ToString();
			erro.ErrorField = "{所属角色编码}";
			erro.ErrorCont = "用户表:{所属角色编码}字段" + value + " 不是有效的角色编码";
			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)
			{
			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> ThreeData(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> FourData(string FileCode, 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>();
			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)
			else
			{
			ExcelErro erro = new ExcelErro();
			erro.RoeNumber = "/";
			erro.ErrorField = "{往来单位编码(唯一)}";
			erro.ErrorCont = "往来单位表:{往来单位编码(唯一)}字段" + excelTable.Rows[i][1].ToString().Trim() + "已存在";
			erro.RoeNumber = (k + 1).ToString();
			erro.ErrorField = "{所属角色编码}";
			erro.ErrorCont = "用户表:{所属角色编码}字段" + excelTable[0].Rows[k][8].ToString().Trim() + " 不是有效的角色编码";
			list.Add(erro);
			}
			}
			if (excelTable[0].Rows[k][9].ToString().Trim() != null && excelTable[0].Rows[k][9].ToString().Trim() != "")
			{
			string[] usergroupcode = Array.ConvertAll<string, string>(excelTable[0].Rows[k][9].ToString().Trim().Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries), s => s.ToString()); //string分割转string[]
			sql = @"select usergroupcode from TGroup where usergroupcode in @usergroupcode";
			dynamicParams.Add("@usergroupcode", usergroupcode);
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt != null && dt.Rows.Count > 0)
			{
			string[] values = excelTable[0].Rows[k][9].ToString().Trim().Split(',');
			var unmatchedValues = values.Except(dt.AsEnumerable().Select(row => row.Field<string>("usergroupcode")));
			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][9].ToString().Trim() + " 不是有效的班组编码";
			list.Add(erro);
			}
			}
			@@ -2194,14 +2214,14 @@
			{
			StuCode = "200";
			message = "数据验证成功";
			count = excelTable.Rows.Count;
			count = excelTable[0].Rows.Count;
			}
			return list;
			}
			#endregion

			#region【Excel上传数据验证,仓库、库位定义】
			public static List<ExcelErro> SixOneData(string FileCode, out string StuCode, out string message, out int count)
			#region【Excel上传数据验证,角色管理】
			public static List<ExcelErro> FourData(List<DataTable> excelTable, out string StuCode, out string message, out int count)
			{
			message = "";
			StuCode = "";
			@@ -2210,41 +2230,192 @@
			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 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 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[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)
			{
			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> FiveData(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 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][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 T_Sec_Stck where code=@code";
			dynamicParams.Add("@code", 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() + "已存在";
			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);
			}
			}
			@@ -2253,16 +2424,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)
			@@ -2286,36 +2457,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 = "";
			@@ -2324,44 +2467,314 @@
			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;
			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> EightData(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 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][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 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[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][0].ToString().Trim() != null && excelTable[1].Rows[k][0].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)
			{
			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 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);
			}
			}
			}
			//判断子表外键不存在于主表主键中的数据
			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)
			{
			@@ -2378,7 +2791,134 @@
			{
			StuCode = "200";
			message = "数据验证成功";
			count = excelTable.Rows.Count;
			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;
			}
			@@ -2971,32 +3511,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);
			}
			}
			@@ -3016,7 +3568,7 @@
			{
			StuCode = "200";
			message = "数据验证成功";
			count = excelTable.Rows.Count;
			count = excelTable[0].Rows.Count;
			}
			return list;
			}
			@@ -3221,124 +3773,8 @@
			#endregion

			#region[Excel上传数据提交]
			#region【Excel数据上传,用户角色】
			public static string TwoSubmit(string FileCode, string User, 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++)
			{
			sql = @"select * from TGroup where group_code=@group_code";
			dynamicParams.Add("@group_code", excelTable[0].Rows[k][2].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt.Rows.Count > 0)
			{
			continue;
			}
			else
			{
			sql = @"insert into TGroup(group_code,group_name,description,lm_user,lm_date,torg_code)
			values(@group_code,@group_name,@description,@Operator,@CreateDate,@torg_code)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			group_code = excelTable[0].Rows[k][2].ToString().Trim(),
			group_name = excelTable[0].Rows[k][3].ToString().Trim(),
			description = excelTable[0].Rows[k][4].ToString().Trim(),
			CreateDate = DateTime.Now.ToString(),
			Operator = User,
			torg_code = excelTable[0].Rows[k][1].ToString().Trim()
			}
			});
			}
			}
			//导入用户
			for (int i = 0; i < excelTable[1].Rows.Count; i++)
			{
			if (excelTable[1].Rows[i][3].ToString().Trim() == "在职")
			{
			Enable = "Y";
			}
			else
			{
			Enable = "N";
			}
			//工资类型
			switch (excelTable[1].Rows[i][8].ToString().Trim())
			{
			case "计件制":
			WageType = "2";
			break;
			case "计时制":
			WageType = "1";
			break;
			default:
			break;
			}
			sql = @"select * from TUser where usercode=@usercode";
			dynamicParams.Add("@usercode", excelTable[1].Rows[i][1].ToString().Trim());
			dt = DapperHelper.selectdata(sql, dynamicParams);
			if (dt.Rows.Count > 0)
			{
			continue;
			}
			sql = @"insert into TUser(usercode,username,password,enable,mobile,lm_date,email,lm_user,stu_torgcode,wagetype,usergroup_code)
			values(@UserCode,@UserName,@password,@Enable,@Mobile,@CreateDate,@Email,@Operator,@StuOrg,@wagetype,@usergroup_code)";
			list.Add(new
			{
			str = sql,
			parm = new
			{
			UserCode = excelTable[1].Rows[i][1].ToString().Trim(),
			UserName = excelTable[1].Rows[i][2].ToString().Trim(),
			password = excelTable[1].Rows[i][4].ToString().Trim(),
			Enable = Enable,
			Mobile = excelTable[1].Rows[i][5].ToString().Trim(),
			CreateDate = DateTime.Now.ToString(),
			Email = excelTable[1].Rows[i][6].ToString().Trim(),
			Operator = User,
			StuOrg = excelTable[1].Rows[i][7].ToString().Trim(),
			wagetype = WageType,
			usergroup_code = excelTable[1].Rows[i][9].ToString().Trim()
			}
			});
			}
			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 OneSubmit(string FileCode, string User, out string StuCode)
			#region【Excel数据上传,组织架构】
			public static string ZerroSubmit(string FileCode, string User, out string StuCode)
			{
			string message = "";
			StuCode = "";
			@@ -3409,14 +3845,47 @@
			}
			#endregion

			#region【Excel数据上传,工位清单】
			public static string ThreeSubmit(string FileCode, string User, out string StuCode)
			#region【Excel数据上传,岗位管理】
			public static string 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 i = 0; i < excelTable[0].Rows.Count; i++)
			{
			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
			{
			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()
			}
			});
			}
			bool aa = DapperHelper.DoTransaction(list);
			if (aa)
			{
			StuCode = "200";
			message = "导入成功！";
			}
			else
			{
			StuCode = "300";
			message = "导入失败！";
			}
			}
			catch (Exception e)
			{
			@@ -3427,8 +3896,59 @@
			}
			#endregion

			#region【Excel数据上传,往来单位清单】
			public static string FourSubmit(string FileCode, string User, out string StuCode)
			#region【Excel数据上传,分组管理】
			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)
			{
			StuCode = "300";
			message = e.Message;
			}
			return message;
			}
			#endregion

			#region【Excel数据上传,人员管理】
			public static string ThreeSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			@@ -3439,42 +3959,36 @@
			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;
			}

			sql = @"insert into TCustomer(code,name,type,conttacts,conttphone,addr,lm_user,lm_date)
			values(@code,@name,@type,@conttacts,@conttphone,@addr,@Operator,@CreateDate)";
			//sql = @"select * from TUser where usercode=@usercode";
			//dynamicParams.Add("@usercode", excelTable[1].Rows[i][1].ToString().Trim());
			//dt = DapperHelper.selectdata(sql, dynamicParams);
			//if (dt.Rows.Count > 0)
			//{
			// continue;
			//}
			sql = @"insert into TUser(usercode,username,password,status,mobile,email,storg_code,post_code,role_code,group_code,is_system_admin,lm_user,lm_date)
			values(@usercode,@username,@password,@status,@mobile,@email,@storg_code,@post_code,@role_code,@group_code,@is_system_admin,@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()
			usercode = excelTable[0].Rows[i][0].ToString().Trim(),
			username = excelTable[0].Rows[i][1].ToString().Trim(),
			password = excelTable[0].Rows[i][2].ToString().Trim(),
			status = excelTable[0].Rows[i][3].ToString().Trim(),
			mobile = excelTable[0].Rows[i][4].ToString().Trim(),
			email = excelTable[0].Rows[i][5].ToString().Trim(),
			storg_code = excelTable[0].Rows[i][6].ToString().Trim(),
			post_code = excelTable[0].Rows[i][7].ToString().Trim(),
			role_code = excelTable[0].Rows[i][8].ToString().Trim(),
			group_code = excelTable[0].Rows[i][9].ToString().Trim(),
			is_system_admin = "N",
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString()
			}
			});
			}
			@@ -3499,8 +4013,85 @@
			}
			#endregion

			#region【Excel数据上传,仓库、库位定义】
			public static string SixOneSubmit(string FileCode, string User, out string StuCode)
			#region【Excel数据上传,角色管理】
			public static string FourSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			string sql = "", datarange = "", datapermissions = "";
			List<object> list = new List<object>();
			var dynamicParams = new DynamicParameters();
			try
			{
			list.Clear();
			//导入角色
			for (int i = 0; i < excelTable[0].Rows.Count; i++)
			{
			//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 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
			{
			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()
			}
			});
			}
			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 FiveSubmit(List<DataTable> excelTable, User us, out string StuCode)
			{
			string message = "";
			StuCode = "";
			@@ -3510,42 +4101,45 @@
			try
			{
			list.Clear();
			List<DataTable> excelTable = new List<DataTable>();
			excelTable = ImportExcel.ExcelToTableList(FileCode);
			//导入仓库
			//导入往来单位类型
			for (int k = 0; k < excelTable[0].Rows.Count; k++)
			{
			sql = @"insert into T_Sec_Stck(code,name,description,lm_user,lm_date)
			values(@code,@name,@description,@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[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
			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 T_Sec_Loca(code,name,description,stock_code,lm_user,lm_date)
			values(@code,@name,@description,@stock_code,@Operator,@CreateDate)";
			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][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[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"
			}
			});
			}
			@@ -3570,14 +4164,103 @@
			}
			#endregion

			#region【Excel数据上传,容器定义】
			public static string SevenSubmit(string FileCode, string User, out string StuCode)
			#region【Excel数据上传,仓库设置】
			public static string SixSubmit(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 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[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"
			}
			});
			}
			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 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)
			{
			@@ -3589,13 +4272,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)
			{
			@@ -3607,42 +4384,53 @@
			#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(),
			idparent = 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,input_date,operation_ration,enable,opc_uom,lm_user,lm_date)
			values(@code,@name,@torg_code,@eqptype_code,@input_date,@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(),
			input_date = excelTable[1].Rows[i][4].ToString().Trim(),
			operation_ration = "100",
			enable = excelTable[1].Rows[i][5].ToString().Trim(),
			opc_uom = "台",
			lm_user = us.usercode,
			lm_date = DateTime.Now.ToString()
			}
			});
			@@ -4287,34 +5075,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()
			}
			});
			}