HEGII.gt.mes.wcf/DK.Service/PMModuleLogic/PMModuleLogic.cs

/*******************************************************************************
 * Copyright(c) 2014 DongkeSoft All rights reserved. / Confidential
 * 类的信息：
 *      1.程序名称：PMModuleLogic.cs
 *      2.功能描述：生产管理
 * 编辑履历：
 *      作者            日期                版本            修改内容
 *      陈冰            2014/09/3           1.00            新建
*******************************************************************************/

using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.IO;
using System.Text;
using Dongke.IBOSS.PRD.Basics.BaseResources;
using Dongke.IBOSS.PRD.Basics.DataAccess;
using Dongke.IBOSS.PRD.Basics.Library;
using Dongke.IBOSS.PRD.Service.DataModels;
using Dongke.IBOSS.PRD.WCF.DataModels; 
using Dongke.IBOSS.PRD.WCF.DataModels.PMModule;
using Oracle.ManagedDataAccess.Client; 

namespace Dongke.IBOSS.PRD.Service.PMModuleLogic
{
	/// <summary>
	/// 生产管理
	/// </summary>
	public partial class PMModuleLogic
	{
		/// <summary>
		/// 构建 计数/检验时返回的信息
		/// </summary>
		/// <returns></returns>
		public static DataTable CreateBarCodeResultTable()
		{
			// 注意：更新表字段时，一定把后续引用的字段全部更新一遍
			DataTable barCodeResultTable = new DataTable("BarCodeTable");
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_errMsg.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_goodsID.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_goodsCode.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_goodsName.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_groutingUserCode.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_groutingUserName.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_groutingUserID.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_groutingNum.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_mouldCode.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_ispublicbody.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_ispublicbodyTrach.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_groutingdate.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_specialRepairFlag.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_isReFire.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_missFlag.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_logoID.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_logoCode.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_logoName.ToString());
			//xuwei add 2020-03-04 添加釉料属性
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_glazeName.ToString());

			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_deliverLimitCycle.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_barcode.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_WaterLabelCode.ToString());
			barCodeResultTable.Columns.Add(Constant.BarCodeResultTableColumns.out_CodeCheckFlag.ToString());

			// 包装装板用
			barCodeResultTable.Columns.Add("GOODSMODELforCheck");
			// 最大装板数量
			barCodeResultTable.Columns.Add("PlateLimitNum", typeof(int));
			//裸瓷标识
			barCodeResultTable.Columns.Add("LuociFlag", typeof(int));
			

			return barCodeResultTable;
		}

		/// <summary>
		/// 构建 校验窑车号时返回的信息
		/// </summary>
		/// <returns></returns>
		public static DataTable CreateKilnCarResultTable()
		{
			// 注意：更新表字段时，一定把后续引用的字段全部更新一遍
			DataTable kilnCarResultTable = new DataTable("KilnCarTable");
			kilnCarResultTable.Columns.Add(Constant.KilnCarResultTableColumns.out_errMsg.ToString());
			kilnCarResultTable.Columns.Add(Constant.KilnCarResultTableColumns.out_kilnCarID.ToString());
			kilnCarResultTable.Columns.Add(Constant.KilnCarResultTableColumns.out_kilnCarName.ToString());
			kilnCarResultTable.Columns.Add(Constant.KilnCarResultTableColumns.out_kilnID.ToString());
			kilnCarResultTable.Columns.Add(Constant.KilnCarResultTableColumns.out_kilnCode.ToString());
			kilnCarResultTable.Columns.Add(Constant.KilnCarResultTableColumns.out_kilnName.ToString());
			return kilnCarResultTable;
		}

		/// <summary>
		/// 校验窑车是否可用
		/// </summary>
		/// <param name="pProcedureId">工序ID</param>
		/// <param name="kilnCarCode">窑车号</param>
		/// <param name="pModelType">类别</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>CheckKilnCarResultEntity实体类</returns>
		/// <remarks>
		/// 陈冰              2014.09.26              新建
		/// </remarks>
		public static CheckKilnCarResultEntity CheckKilnCar(int pProcedureId, string kilnCarCode, int pModelType, SUserInfo sUserInfo)
		{
			CheckKilnCarResultEntity kilnCarResultEntity = new CheckKilnCarResultEntity();
			IDBConnection oracleConn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleConn.Open();
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter("in_accountID",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter("in_kilnCarCode",OracleDbType.NVarchar2, kilnCarCode,ParameterDirection.Input),
					new OracleParameter("in_modelType",OracleDbType.Int32, pModelType,ParameterDirection.Input),
					new OracleParameter("out_errMsg",OracleDbType.NVarchar2,2000,null,ParameterDirection.Output),
					new OracleParameter("out_result",OracleDbType.RefCursor, ParameterDirection.Output),
					new OracleParameter("in_procedureid",OracleDbType.Int32, pProcedureId,ParameterDirection.Input),
                    // 验证能否卸窑
                    new OracleParameter("in_UserID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
				};
				DataSet returnDataSet = oracleConn.ExecStoredProcedure("PRO_PM_CheckKilnCar", paras);
				kilnCarResultEntity.ErrMsg = paras[3].Value.ToString() == "null" ? string.Empty : paras[3].Value.ToString().Replace("\\n\\r", "\n\r");
				if (returnDataSet == null || returnDataSet.Tables.Count <= 0)
				{
					kilnCarResultEntity.KilnCarInfos = new List<KilnCarInfo>();
				}
				else
				{
					kilnCarResultEntity.KilnCarInfos = DataConvert.TableConvertToObject<KilnCarInfo>(returnDataSet.Tables[0]);
				}
				return kilnCarResultEntity;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (oracleConn.ConnState == ConnectionState.Open)
				{
					oracleConn.Close();
				}
			}
		}

		/// <summary>
		/// 由工序获取产缺陷列表
		/// </summary>
		/// <param name="procedureID">工序ID</param>
		/// <returns>DataSet</returns>
		public static DataSet GetDefectByProcedure(int procedureID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select TP_MST_Defect.DefectID as DefectFlagID,TP_MST_Defect.DefectCode,
                                    TP_MST_Defect.DefectName as ViewDefectFlagName, 
                                    concat(TP_MST_Defect.DefectCode||'->',TP_MST_Defect.DefectName) as DefectFlagName
                                    from TP_PC_ProcedureDefect 
                                    left join TP_MST_Defect on TP_PC_ProcedureDefect.DefectID=TP_MST_Defect.DefectID
                                    where TP_MST_Defect.valueflag = '1' and TP_PC_ProcedureDefect.procedureID=" + procedureID;
				DataSet ds = con.GetSqlResultToDs(sqlString);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 由当前检验工序ID和缺陷Code获取缺陷数据
		/// </summary>
		/// <param name="procedureID">当前检验工序ID</param>
		/// <param name="defectCode">缺陷Code</param>
		/// <returns>object</returns>
		/// <remarks>
		/// 陈冰              2014.10.04              新建
		/// </remarks>
		public static object GetDefectByProcedureIDAndDefectCode(int procedureID, string defectCode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select TP_MST_Defect.DefectID,
                                           TP_MST_Defect.DefectName,
                                           TP_PC_ProcedureDefect.procedureID
                                      from TP_MST_Defect
                                      left join TP_PC_ProcedureDefect on TP_MST_Defect.DefectID =
                                                                         TP_PC_ProcedureDefect.DefectID
                                                                     and TP_PC_ProcedureDefect.procedureID = :procedureID
                                     where TP_MST_Defect.DefectCode = :defectCode and TP_MST_Defect.Valueflag='1'";
				OracleParameter[] paras = new OracleParameter[] {
					new OracleParameter(":procedureID",procedureID),
					new OracleParameter(":defectCode",defectCode),
				};
				DataSet resultds = con.GetSqlResultToDs(sqlString, paras);
				if (resultds != null && resultds.Tables.Count > Constant.INT_IS_ZERO)
				{
					string errMsg = string.Empty;
					int defectID = 0;
					string defectName = string.Empty;
					if (resultds.Tables[0].Rows.Count == Constant.INT_IS_ZERO)
					{
						errMsg = "缺陷在系统中不存在";
					}
					else
					{
						if (string.IsNullOrEmpty(resultds.Tables[0].Rows[0]["ProcedureID"].ToString()))
						{
							errMsg = "当前工序没有配置该缺陷";
						}
						else
						{
							defectID = int.Parse(resultds.Tables[0].Rows[0]["DefectID"].ToString());
							defectName = resultds.Tables[0].Rows[0]["DefectName"].ToString();
						}
					}
					return new { ErrMsg = errMsg, DefectID = defectID, DefectName = defectName };
				}
				else
				{
					return null;
				}
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据产品ID查出缺陷位置
		/// </summary>
		/// <param name="goodsID">产品ID</param>
		/// <returns>DataSet</returns>
		public static DataSet GetDefectLocaionByGoodsID(int goodsID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select TP_MST_DEFECTPOSITION.DEFECTPOSITIONID,TP_MST_DEFECTPOSITION.DEFECTPOSITIONCODE,TP_MST_DEFECTPOSITION.DEFECTPOSITIONNAME
                                    ,concat(TP_MST_DEFECTPOSITION.DEFECTPOSITIONCODE||'->',TP_MST_DEFECTPOSITION.DEFECTPOSITIONNAME) as DEFECTPOSITIONCODEANDNAME from tp_mst_goodsdefectposition left join TP_MST_DEFECTPOSITION
                                    on tp_mst_goodsdefectposition.defectpositionid=TP_MST_DEFECTPOSITION.defectpositionid
                                    where tp_mst_goodsdefectposition.goodsid=" + goodsID;
				DataSet ds = con.GetSqlResultToDs(sqlString);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据缺陷位置
		/// </summary>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>DataSet</returns>
		public static DataSet GetDefectLocaion(SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select DEFECTPOSITIONID,
                                            DEFECTPOSITIONCODE,
                                            DEFECTPOSITIONNAME,
                                            concat(DEFECTPOSITIONCODE||'->',DEFECTPOSITIONNAME) as DEFECTPOSITIONCODEANDNAME
                                    from TP_MST_DEFECTPOSITION
                                    where AccountID=:accountID and ValueFlag=1";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":accountID",sUserInfo.AccountID),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据产品ID查出缺陷位置
		/// </summary>
		/// <param name="goodsID">产品ID</param>
		/// <param name="positionCode">位置编码</param>
		/// <returns>object</returns>
		public static object GetDefectPositionByGoodsIDAndPositionCode(int goodsID, string positionCode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select tp_mst_defectposition.defectpositionid,
                                       tp_mst_defectposition.defectpositionname,
                                       tp_mst_goodsdefectposition.goodsid
                                  from  tp_mst_defectposition
                                  left join tp_mst_goodsdefectposition on tp_mst_goodsdefectposition.defectpositionid =
                                                                     tp_mst_defectposition.defectpositionid
                                                                     and  tp_mst_goodsdefectposition.goodsid =:goodsid
                                 where tp_mst_defectposition.defectpositioncode = :defectpositioncode and tp_mst_defectposition.Valueflag='1'";

				OracleParameter[] paras = new OracleParameter[] {
					new OracleParameter(":goodsid",goodsID),
					new OracleParameter(":defectpositioncode",positionCode),
				};
				DataSet resultds = con.GetSqlResultToDs(sqlString, paras);
				if (resultds != null && resultds.Tables.Count > Constant.INT_IS_ZERO)
				{
					string errMsg = string.Empty;
					int defectPositionID = 0;
					string defectpositionname = string.Empty;
					if (resultds.Tables[0].Rows.Count == Constant.INT_IS_ZERO)
					{
						errMsg = "缺陷位置在系统中不存在";
					}
					else
					{
						if (string.IsNullOrEmpty(resultds.Tables[0].Rows[0]["goodsid"].ToString()))
						{
							errMsg = "当前产品没有配置该缺陷位置";
						}
						else
						{
							defectPositionID = int.Parse(resultds.Tables[0].Rows[0]["defectPositionID"].ToString());
							defectpositionname = resultds.Tables[0].Rows[0]["defectpositionname"].ToString();
						}
					}
					return new { ErrMsg = errMsg, DefectPositionID = defectPositionID, DefectPositionName = defectpositionname };
				}
				else
				{
					return null;
				}
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 通过条码查出责任工序
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <param name="defectid">缺陷ID</param>
		/// <returns>DataSet</returns>
		public static DataSet GetDutyProcedureByBarCode(string barcode, int defectid, int accountid)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				DataSet dsReturn = new DataSet();
				//                string sqlString = @"select TP_PM_ProductionDataIn.ProductionDataID, DutyProcedureID,DutyProcedureCode,DutyProcedureName,NodeType,ModelType from
				//                                    (
				//                                    select TP_PM_ProductionDataIn.ProductionDataID,TP_PM_ProductionDataIn.ProcedureID as DutyProcedureID,
				//                                           TP_PM_ProductionDataIn.ProcedureCode as DutyProcedureCode,
				//                                           TP_PM_ProductionDataIn.ProcedureName as DutyProcedureName,
				//                                           TP_PM_ProductionDataIn.NodeType,
				//                                           TP_PM_ProductionDataIn.ModelType 
				//                                    from TP_PM_ProductionDataIn
				//                                    where valueflag = '1' and TP_PM_ProductionDataIn.Barcode=:Barcode
				//                                    order by TP_PM_ProductionDataIn.ProductionDataID
				//                                    ) TP_PM_ProductionDataIn
				//                                    where exists 
				//                                    (
				//                                     select 
				//                                     TP_PC_DefectProcedureJobs.DefectID,
				//                                     TP_PC_DefectProcedureJobs.ProductionLineID,
				//                                     TP_PC_DefectProcedureJobs.ProcedureID,
				//                                     TP_PC_DefectProcedureJobs.NodeNo,
				//                                     TP_PC_DefectProcedureJobs.JobsID
				//                                     from TP_PC_DefectProcedureJobs
				//                                     where  TP_PC_DefectProcedureJobs.DefectID=:DefectID
				//                                       and  TP_PM_ProductionDataIn.DutyProcedureID=TP_PC_DefectProcedureJobs.ProcedureID
				//                                    )";
				//string sqlString =
				//"SELECT pdin.ProductionDataID\n" +
				//"      ,pdin.ProcedureID      AS DutyProcedureID\n" +
				//"      ,pdin.ProcedureCode    AS DutyProcedureCode\n" +
				//"      ,pdin.ProcedureName    AS DutyProcedureName\n" +
				//"      ,pdin.NodeType\n" +
				//"      ,pdin.ModelType\n" +
				//"      ,pdin.classessettingid\n" +
				//"      ,pdin.userid\n" +
				//"      ,pdin.usercode\n" +
				//"      ,pdin.username\n" +
				//"  FROM TP_PM_ProductionDataIn pdin\n" +
				//" WHERE pdin.valueflag = '1'\n" +
				//"   AND pdin.accountid = :accountid\n" +
				//"   AND pdin.Barcode = :Barcode\n" +
				//"   AND EXISTS (SELECT 1\n" +
				//"          FROM TP_PC_DefectProcedureJobs dpJobs\n" +
				//"         WHERE dpJobs.DefectID = :DefectID\n" +
				//"           AND pdin.ProcedureID = dpJobs.ProcedureID)\n" +
				//" ORDER BY pdin.ProductionDataID";
				// 去掉重复工序（取最后一个）
				string sqlString = "select pdin.ProductionDataID\n" +
				"      ,pdin.ProcedureID      as DutyProcedureID\n" +
				"      ,pdin.ProcedureCode    as DutyProcedureCode\n" +
				"      ,pdin.ProcedureName    as DutyProcedureName\n" +
				"      ,pdin.NodeType\n" +
				"      ,pdin.ModelType\n" +
				"      ,pdin.classessettingid\n" +
				"      ,pdin.userid\n" +
				"      ,pdin.usercode\n" +
				"      ,pdin.username\n" +
				"  from TP_PM_ProductionDataIn pdin\n" +
				" where pdin.productiondataid in\n" +
				"       (select max(pdi.productiondataid) pdid\n" +
				"          from TP_PM_ProductionDataIn pdi\n" +
				"         where pdi.valueflag = '1'\n" +
				"           and pdi.accountid = :accountid\n" +
				"           and pdi.Barcode = :Barcode\n" +
				"           and exists\n" +
				"         (select 1\n" +
				"                  from TP_PC_DefectProcedureJobs dpJobs\n" +
				"                 where dpJobs.DefectID = :DefectID\n" +
				"                   and pdi.ProcedureID = dpJobs.ProcedureID)\n" +
				"         group by pdi.ProcedureID)\n" +
				" order by pdin.ProductionDataID";

				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":accountid",OracleDbType.Int32, accountid,ParameterDirection.Input),
					new OracleParameter(":Barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
					new OracleParameter(":DefectID",OracleDbType.Int32, defectid,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				ds.Tables[0].TableName = "TProcedure";

				//sqlString = "Select DictionaryID,DictionaryValue"
				//            + " from TP_MST_DataDictionary where valueflag = 1 and DictionaryType = 'ASE002' and AccountID = :AccountID";
				//paras = new Oracle.ManagedDataAccess.Client.OracleParameter[] 
				//           {
				//                new Oracle.ManagedDataAccess.Client.OracleParameter(":AccountID",accountid),
				//            };
				//DataSet ds2 = con.GetSqlResultToDs(sqlString, paras);
				//ds2.Tables[0].TableName = "TDataDictionary";

				sqlString = "select procedureid,jobsid from TP_PC_DefectProcedureJobs where TP_PC_DefectProcedureJobs.Defectid=:Defectid";

				paras = new Oracle.ManagedDataAccess.Client.OracleParameter[]
						   {
								new Oracle.ManagedDataAccess.Client.OracleParameter(":Defectid",defectid),
							};
				DataSet ds3 = con.GetSqlResultToDs(sqlString, paras);
				ds3.Tables[0].TableName = "TP_PC_DefectProcedureJobs";
				if (!dsReturn.Tables.Contains("TProcedure"))
				{
					dsReturn.Tables.Add(ds.Tables[0].Copy());
				}
				//if (!dsReturn.Tables.Contains("TDataDictionary"))
				//{
				//    dsReturn.Tables.Add(ds2.Tables[0].Copy());
				//}
				if (!dsReturn.Tables.Contains("TP_PC_DefectProcedureJobs"))
				{
					dsReturn.Tables.Add(ds3.Tables[0].Copy());
				}
				return dsReturn;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 通过条码与工序查出责任工号
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <param name="dutyProcedureID">责任工序</param>
		/// <returns>DataSet</returns>
		public static DataSet GetDutyProcedureCodeByBarCode(string barcode, int dutyProcedureID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select UserID,UserCode,UserName,Remarks,ProductionDataID from TP_PM_ProductionDataIn
                                     where Barcode=:Barcode and ProcedureID=:ProcedureID and valueflag=1";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":Barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
					new OracleParameter(":ProcedureID",OracleDbType.Int32, dutyProcedureID,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 责任工序查出工号根据生产数据ID
		/// </summary>
		/// <param name="ProductionDataID"></param>
		/// <returns></returns>
		public static DataSet GetDutyProcedureCodeByProductionDataID(int ProductionDataID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select UserID,UserCode,UserName,Remarks,ProductionDataID from TP_PM_ProductionDataIn
                                     where ProductionDataID=:ProductionDataID";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":ProductionDataID",OracleDbType.Int32, ProductionDataID,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据所选工序默认查出工种信息
		/// </summary>
		/// <param name="userID">工号ID</param>
		/// <param name="productionDataID">生产数据ID</param>
		/// <returns>DataSet</returns>
		public static DataSet GetDutyJobsCodeByUser(int userID, int productionDataID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				//                string sqlString = @"select distinct
				//                                    TP_PM_Producer.UserID,TP_MST_Jobs.JobsID,TP_MST_Jobs.JobsName,TP_MST_Jobs.JobsCode
				//                                     from TP_PM_Producer
				//                                     left join TP_MST_Jobs
				//                                     on TP_PM_Producer.UJobsID=TP_MST_Jobs.JobsID
				//                                     where TP_PM_Producer.UserID=:UserID 
				//                                     and TP_PM_Producer.UJobsID in
				//                                    (
				//                                     select 
				//                                     JobsID
				//                                     from TP_PC_DefectProcedureJobs where ProcedureID=
				//                                                    (
				//                                                        Select ProcedureID from TP_PM_ProductionDataIn where ProductionDataID=:ProductionDataID
				//                                                    )
				//                                    )";
				string sqlString = @"select distinct tp_pc_classesdetail.UserID,
                                                TP_MST_Jobs.JobsID,
                                                TP_MST_Jobs.JobsName,
                                                TP_MST_Jobs.JobsCode
                                  from tp_pc_classesdetail
                                  left join TP_MST_Jobs on tp_pc_classesdetail.UJobsID = TP_MST_Jobs.JobsID
                                 where tp_pc_classesdetail.UserID = :UserID
                                   and tp_pc_classesdetail.UJobsID in
                                       (select JobsID
                                          from TP_PC_DefectProcedureJobs
                                         where ProcedureID =
                                               (Select ProcedureID
                                                  from TP_PM_ProductionDataIn
                                                 where ProductionDataID = :ProductionDataID)
                                    )";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":UserID",OracleDbType.Int32, userID,ParameterDirection.Input),
					new OracleParameter(":ProductionDataID",OracleDbType.Int32, productionDataID,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据所选生产数据ID，用户ID及工种选出责任员工
		/// </summary>
		/// <param name="productionDataID">生产数据ID</param>
		/// <param name="userID">用户ID</param>
		/// <param name="jobs">工种ID</param>
		/// <returns>DataSet</returns>
		public static DataSet GetDutyStaffByUserIDAndJobs(int productionDataID, int userID, int jobs)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				//                string sqlString = @"select TP_HR_Staff.StaffID,TP_HR_Staff.StaffCode,TP_HR_Staff.StaffName,TP_HR_Staff.StaffStatus,TP_PM_Producer.SJobsID
				//                                     from TP_PM_Producer 
				//                                     left join TP_HR_Staff on TP_PM_Producer.StaffID=TP_HR_Staff.StaffID
				//                                     where TP_PM_Producer.ProductionDataID=:ProductionDataID
				//                                     and TP_PM_Producer.UserID=:UserID and TP_PM_Producer.UJobsID=:JobsID
				//                                    ";
				string sqlString = @"select TP_HR_Staff.StaffID,
                                     TP_HR_Staff.StaffCode,
                                     TP_HR_Staff.StaffName,
                                     TP_HR_Staff.StaffStatus,
                                     tp_pc_classesdetail.SJobsID
                                      from tp_pc_classesdetail 
                                      left join TP_HR_Staff on tp_pc_classesdetail.StaffID =
                                                               TP_HR_Staff.StaffID
                                     where tp_pc_classesdetail.ClassesSettingID=(select ClassesSettingID from tp_pm_productiondatain where productiondataid=:ProductionDataID)
                                       and tp_pc_classesdetail.UserID = :UserID
                                       and tp_pc_classesdetail.UJobsID = :JobsID
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":ProductionDataID",OracleDbType.Int32, productionDataID,ParameterDirection.Input),
					new OracleParameter(":UserID",OracleDbType.Int32, userID,ParameterDirection.Input),
					new OracleParameter(":JobsID",OracleDbType.Int32, jobs,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据传入的实体获取进度考核奖惩信息
		/// </summary>
		/// <param name="searchAdminRAPEntity">查询实体</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>DataSet进度考核奖惩信息表</returns>
		public static DataSet SearcStaffAdminRAPInfo(SearchProgressRAPEntity searchProgressRAPEntity, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				string strIdList = string.Empty;
				if (searchProgressRAPEntity.IDList != null && searchProgressRAPEntity.IDList.Length > 0)
				{
					strIdList = DataConvert.ConvertListToSqlInWhere(searchProgressRAPEntity.IDList);
				}
				con.Open();
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter("in_accountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter("in_staffID",OracleDbType.Int32,searchProgressRAPEntity.StaffID,ParameterDirection.Input),
					new OracleParameter("in_rapType",OracleDbType.Double,searchProgressRAPEntity.RAPType,ParameterDirection.Input),
					new OracleParameter("in_startRAPDate",OracleDbType.Date,searchProgressRAPEntity.StartRAPDate,ParameterDirection.Input),
					new OracleParameter("in_endRAPDate",OracleDbType.Date,searchProgressRAPEntity.EndRAPDate,ParameterDirection.Input),
					new OracleParameter("in_startRAPAmount",OracleDbType.Double,searchProgressRAPEntity.StartRAPAmount,ParameterDirection.Input),
					new OracleParameter("in_endRAPAmount",OracleDbType.Double,searchProgressRAPEntity.EndRAPAmount,ParameterDirection.Input),
					new OracleParameter("in_auditStatus",OracleDbType.Int32,searchProgressRAPEntity.AuditStatus,ParameterDirection.Input),
					new OracleParameter("in_settlementFlag",OracleDbType.Char,searchProgressRAPEntity.SettlementFlag,ParameterDirection.Input),
					new OracleParameter("in_valueFlag",OracleDbType.Char,searchProgressRAPEntity.ValueFlag,ParameterDirection.Input),
					new OracleParameter("in_sIDList",OracleDbType.Varchar2,strIdList,ParameterDirection.Input),
					new OracleParameter("out_result",OracleDbType.RefCursor, ParameterDirection.Output),
				};
				return con.ExecStoredProcedure("PRO_PM_StaffProgressRAP", paras);
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据条码获取窑炉窑车信息
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns>DataSet</returns>
		public static DataSet GetKilnCarByBarCode(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				//                string sqlString = @"
				//                                    select 
				//                                    TP_MST_KilnCar.KilnCarCode,
				//                                    TP_MST_Kiln.KilnCode,
				//                                    TP_MST_DataDictionary.Dictionaryvalue
				//                                    from TP_PM_KilnCarGoods
				//                                    left join TP_MST_KilnCar
				//                                    on TP_PM_KilnCarGoods.KilnCarID=TP_MST_KilnCar.Kilncarid
				//                                    left join TP_MST_Kiln
				//                                    on TP_MST_KilnCar.Kilnid=TP_MST_Kiln.Kilnid
				//                                    left join TP_MST_DataDictionary							
				//                                    on TP_PM_KilnCarGoods.KilnCarPosition=TP_MST_DataDictionary.DictionaryID
				//                                    where TP_PM_KilnCarGoods.Barcode=:Barcode
				//                                    ";
				string sqlString = @"
                                    select 
                                    TP_PM_InProduction.KilnCarCode,
                                    TP_PM_InProduction.KilnCode,
                                    TP_MST_DataDictionary.Dictionaryvalue
                                    from TP_PM_InProduction
                                    inner join TP_MST_DataDictionary
                                    on TP_PM_InProduction.KilnCarPosition=TP_MST_DataDictionary.DictionaryID
                                    where TP_PM_InProduction.Barcode=:Barcode
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":Barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		#region 生产数据

		/// <summary>
		/// 查询在产产品数据
		/// </summary>
		/// <param name="searchInProductionEntity">在产产品数据实体</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>DataSet在产产品数据信息表</returns>
		public static DataSet GetInProductionData(SearchInProductionEntity searchInProductionEntity, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				OracleParameter[] paras = new OracleParameter[]{
				   new OracleParameter("in_barCode",OracleDbType.Varchar2,searchInProductionEntity.BarCode,ParameterDirection.Input),
				   new OracleParameter("in_productionLineId",OracleDbType.Varchar2,searchInProductionEntity.ProductionLineIDS,ParameterDirection.Input),
				   new OracleParameter("in_completeProcedureId",OracleDbType.Varchar2,searchInProductionEntity.ProcedureIDS,ParameterDirection.Input),
				   new OracleParameter("in_goodsId",OracleDbType.Varchar2,searchInProductionEntity.GoodsIDS,ParameterDirection.Input),
				   new OracleParameter("in_userId",OracleDbType.Varchar2,searchInProductionEntity.UserIDS,ParameterDirection.Input),
				   new OracleParameter("in_groutingLineId",OracleDbType.Varchar2,searchInProductionEntity.GroutingLineIDS,ParameterDirection.Input),
				   new OracleParameter("in_gMouldTypeId",OracleDbType.Varchar2,searchInProductionEntity.GMouldTypeIDS,ParameterDirection.Input),
				   new OracleParameter("in_accountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
				   new OracleParameter("in_createTimeStart",OracleDbType.Varchar2,searchInProductionEntity.CreateTimeStart,ParameterDirection.Input),
				   new OracleParameter("in_createTimeEnd",OracleDbType.Varchar2,searchInProductionEntity.CreateTimeEnd,ParameterDirection.Input),
				   new OracleParameter("out_result",OracleDbType.RefCursor, ParameterDirection.Output),
				};

				DataSet dsInproduction = con.ExecStoredProcedure("PRO_PM_GetInProductionData", paras);
				return dsInproduction;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 查询成品数据
		/// </summary>
		/// <param name="searchInProductionEntity">产成品数据实体</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>DataSet产成品数据信息表</returns>
		public static DataSet GetFinishedProductionData(SearchFinishedProductEntity searchFinishedProductionEntity, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				OracleParameter[] paras = new OracleParameter[]{
				   new OracleParameter("in_barCode",OracleDbType.Varchar2,searchFinishedProductionEntity.BarCode,ParameterDirection.Input),
				   new OracleParameter("in_productionLineId",OracleDbType.Varchar2,searchFinishedProductionEntity.ProductionLineIDS,ParameterDirection.Input),
				   new OracleParameter("in_goodsId",OracleDbType.Varchar2,searchFinishedProductionEntity.GoodsIDS,ParameterDirection.Input),
				   new OracleParameter("in_groutingLineId",OracleDbType.Varchar2,searchFinishedProductionEntity.GroutingLineIDS,ParameterDirection.Input),
				   new OracleParameter("in_gMouldTypeId",OracleDbType.Varchar2,searchFinishedProductionEntity.GMouldTypeIDS,ParameterDirection.Input),
				   new OracleParameter("in_accountDateStart",OracleDbType.Varchar2,searchFinishedProductionEntity.AccountDateStart,ParameterDirection.Input),
				   new OracleParameter("in_accountDateEnd",OracleDbType.Varchar2,searchFinishedProductionEntity.AccountDateEnd,ParameterDirection.Input),
				   new OracleParameter("in_createTimeStart",OracleDbType.Varchar2,searchFinishedProductionEntity.CreateTimeStart,ParameterDirection.Input),
				   new OracleParameter("in_createTimeEnd",OracleDbType.Varchar2,searchFinishedProductionEntity.CreateTimeEnd,ParameterDirection.Input),
				   new OracleParameter("in_accountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
				   new OracleParameter("out_result",OracleDbType.RefCursor, ParameterDirection.Output),
				};
				DataSet dsInproduction = con.ExecStoredProcedure("PRO_PM_GetFinishdProductData", paras);
				return dsInproduction;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 查询半检数据一览
		/// </summary>
		/// <param name="SearchSemiTestDetailEntity">查询半检数据明细实体类</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>DataSet</returns>
		public static DataSet GetSearchSemiTestListModule(SemiTestDetailEntity semiTestDetailEntity, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				OracleParameter[] paras = new OracleParameter[]{
				  new OracleParameter("in_goodsId",OracleDbType.Varchar2,semiTestDetailEntity.GoodsIDS,ParameterDirection.Input),
				  new OracleParameter("in_testUserID",OracleDbType.Varchar2,semiTestDetailEntity.TestUserIDS,ParameterDirection.Input),
				  new OracleParameter("in_groutingUserID",OracleDbType.Varchar2,semiTestDetailEntity.GroutingUserIDS,ParameterDirection.Input),
				  new OracleParameter("in_semitesttype",OracleDbType.Int32,semiTestDetailEntity.SemiTestType,ParameterDirection.Input),
				  new OracleParameter("in_remarks",OracleDbType.Varchar2,semiTestDetailEntity.Remarks,ParameterDirection.Input),
				  new OracleParameter("in_userPurviews",OracleDbType.Varchar2,semiTestDetailEntity.UserPurviews,ParameterDirection.Input),
				  new OracleParameter("in_semiTestDateStart",OracleDbType.Varchar2,semiTestDetailEntity.SemiTestDateStart,ParameterDirection.Input),
				  new OracleParameter("in_semiTestDateEnd",OracleDbType.Varchar2,semiTestDetailEntity.SemiTestDateEnd,ParameterDirection.Input),
				  new OracleParameter("in_accountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
				  new OracleParameter("out_result",OracleDbType.RefCursor, ParameterDirection.Output),
				};
				DataSet dsSearchReport = con.ExecStoredProcedure("PRO_PM_GetSemiTestList", paras);
				return dsSearchReport;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		#endregion

		#region 校验条码是否可以下车

		/// <summary>
		/// 校验条码是否可以下车
		/// </summary>
		/// <param name="procedureID">当前工序</param>
		/// <param name="barcode">产品条码</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>CheckCancelLoadCar</returns>
		public static CheckCancelLoadCar CheckCancelLoadCar(int procedureID, string barcode, SUserInfo sUserInfo)
		{
			IDBConnection oracleConn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleConn.Open();
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter("in_barcode",OracleDbType.Varchar2,barcode,ParameterDirection.Input),
					new OracleParameter("in_procedureid",OracleDbType.Int32,procedureID,ParameterDirection.Input),
					new OracleParameter("in_accountID",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter("out_errMsg",OracleDbType.NVarchar2,200,null,ParameterDirection.Output),
					new OracleParameter("out_goodscode",OracleDbType.NVarchar2,50,null,ParameterDirection.Output),
					new OracleParameter("out_goodsname",OracleDbType.NVarchar2,50,null,ParameterDirection.Output),
					new OracleParameter("out_kilncarcode",OracleDbType.NVarchar2,50,null,ParameterDirection.Output),
				};
				oracleConn.ExecStoredProcedure("PRO_PM_CheckCancelLoadCar", paras);
				CheckCancelLoadCar checkCancelLoadCar = new CheckCancelLoadCar();
				checkCancelLoadCar.ErrMsg = paras[3].Value.ToString() == "null" ? "" : paras[3].Value.ToString().Replace("\\n\\r", "\n\r");
				checkCancelLoadCar.GoodsCode = paras[4].Value.ToString() == "null" ? "" : paras[4].Value.ToString();
				checkCancelLoadCar.GoodsName = paras[5].Value.ToString() == "null" ? "" : paras[5].Value.ToString();
				checkCancelLoadCar.KilnCarCode = paras[6].Value.ToString() == "null" ? "" : paras[6].Value.ToString();
				return checkCancelLoadCar;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (oracleConn.ConnState == ConnectionState.Open)
				{
					oracleConn.Close();
				}
			}
		}

		#endregion

		/// <summary>
		/// 根据所选生产数据ID,显示成检数据信息
		/// </summary>
		/// <param name="productionDataID">生产数据ID</param>
		/// <returns>DataSet</returns>
		public static DataSet GetProductionDataByID(int productionDataID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				DataSet dsReturn = new DataSet();
				string sqlString = @"select 
                                    TP_PM_ProductionData.Barcode as BarCode,
                                    TP_PM_ProductionData.Goodsid as GoodsID,
                                    TP_PM_ProductionData.Goodscode as GoodsCode,
                                    TP_PM_ProductionData.Goodsname as GoodsName,
                                    TP_PM_ProductionData.GoodsLevelID as DefectFlagID,
                                    TP_PM_ProductionData.Reworkprocedureid as ReworkProcedureID,
                                    TP_PM_ProductionData.Remarks as Remarks,
                                    TP_PM_ProductionData.Userid as UserID,
                                    TP_PM_ProductionData.UserCode as UserCode,
                                    TP_PM_ProductionData.UserName as UserName,
                                    TP_PM_ProductionData.Goodsleveltypeid as GoodsLevelTypeID,
                                    TP_PM_ProductionData.SpecialRepairflag,
                                    TP_PM_ProductionData.UserCode,
                                    TP_PM_ProductionData.KilnCode,
                                    TP_PM_ProductionData.KilnCarCode,
                                    TP_PM_ProductionData.GroutingUserCode,
                                    TP_PM_ProductionData.GroutingMouldCode as MouldCode,
                                    TP_PM_ProductionData.GroutingNum,
                                    TP_PM_ProductionData.GroutingDate,
                                    TP_MST_DataDictionary.Dictionaryvalue,
                                    TP_PM_ProductionData.IsPublicBody,
                                    TP_MST_Logo.logoid,
                                    TP_MST_Logo.logocode,
                                    TP_MST_Logo.logoname,
                                    TP_PM_ProductionData.CreateTime,
                                    TP_PM_ProductionData.CheckTime
                                    from TP_PM_ProductionData
                                    left join TP_MST_DataDictionary
                                    on TP_PM_ProductionData.KilnCarPosition=TP_MST_DataDictionary.DictionaryID
                                    left join TP_MST_Logo
                                    on TP_PM_ProductionData.logoid=TP_MST_Logo.logoid
                                    where 
                                    TP_PM_ProductionData.Productiondataid=:ProductionDataID
                                    ";
				string sqlString2 = @"
                                    select 
                                    TP_PM_Defect.ProductionDefectID as ProductionDefectID,
                                    TP_PM_Defect.Barcode as BarCode,
                                    TP_PM_Defect.DefectID as DefectID,
                                    TP_PM_Defect.Defectname as DefectName,
                                    TP_PM_Defect.Defectcode as DefectCode,
                                    TP_PM_Defect.Defectpositionid as DefectPositionID,
                                    TP_PM_Defect.Defectpositionname as DefectPositionName,
                                    TP_PM_Defect.Defectpositioncode as DefectPositionCode,
                                    TP_PM_Defect.Defectprocedureid as DefectProcedureID,
                                    TP_PM_Defect.Defectprocedurename as DefectProcedureName,
                                    TP_PM_Defect.Defectprocedurecode as DefectProcedureCode,
                                    TP_PM_Defect.Defectuserid as DefectUserID,
                                    TP_PM_Defect.Defectusername as DefectUserName,
                                    TP_PM_Defect.Defectusercode as DefectUserCode,
                                    TP_PM_Defect.DefectJobs as Jobs,
                                    nvl(TP_PM_Defect.MissedUserID,-1) as MissedUserID,
                                    TP_PM_Defect.MissedUserCode,
                                    TP_PM_Defect.MissedUserName,
                                    TP_MST_Jobs.Jobsname as JobsText,
                                    TP_PM_Defect.Remarks as DefectRemarks,
                                    TP_PM_Defect.Productiondataid as ProductionDataID,
                                    nvl(TP_PM_Defect.DefectProductionDataID,0) as DefectProductionDataID,
                                    TP_PM_Defect.Defectfine as DefectFineID,
                                    TP_MST_DefectFine.DefectFineCode as DefectFineValue,
                                    TP_PM_Defect.SpecialDefect,
                                    TP_PM_Defect.DefectDeductionNum,
                                    TP_PM_Defect.CheckTime
                                    from TP_PM_Defect
                                    left join TP_MST_Jobs
                                    on TP_PM_Defect.Defectjobs=TP_MST_Jobs.JobsID
                                    left join TP_MST_DefectFine
                                    on TP_PM_Defect.Defectfine= TP_MST_DefectFine.DefectFineid
                                    where TP_PM_Defect.Productiondataid =:ProductionDataID";
				string sqlString3 = @"select 
                               TP_PM_DefectResponsible.ProductionDefectID as ProductionDefectID,
                               TP_PM_DefectResponsible.Staffid as StaffID,
                               TP_HR_Staff.Staffcode as StaffCode,
                               TP_HR_Staff.Staffname as StaffName,
                               TP_PM_DefectResponsible.Staffstatus as StaffStatus
                               from TP_PM_DefectResponsible
                               left join TP_HR_Staff
                               on TP_PM_DefectResponsible.StaffID=TP_HR_Staff.Staffid
                               where TP_PM_DefectResponsible.Productiondefectid in
                               (
                                select ProductionDefectID from TP_PM_Defect where TP_PM_Defect.Productiondataid=:ProductionDataID
                               )";
				string sqlString4 = @" select
                               TP_PM_DefectImage.ProductionDefectID,
                               TP_PM_DefectImage.Thumbnailpath,
                               TP_PM_DefectImage.Imagepath
                               from TP_PM_DefectImage
                               where TP_PM_DefectImage.Productiondefectid in
                               (
                                select ProductionDefectID from TP_PM_Defect where TP_PM_Defect.Productiondataid=:ProductionDataID
                                 )";
				string sqlString5 = @"select 
                               TP_PM_DefectMissedResponsible.ProductionDefectID as ProductionDefectID,
                               TP_PM_DefectMissedResponsible.Staffid as StaffID,
                               TP_HR_Staff.Staffcode as StaffCode,
                               TP_HR_Staff.Staffname as StaffName,
                               TP_PM_DefectMissedResponsible.Staffstatus as StaffStatus,
                               TP_PM_DefectMissedResponsible.UJobsID,
                               TP_PM_DefectMissedResponsible.SJobsID
                               from TP_PM_DefectMissedResponsible
                               left join TP_HR_Staff
                               on TP_PM_DefectMissedResponsible.StaffID=TP_HR_Staff.Staffid
                               where TP_PM_DefectMissedResponsible.Productiondefectid in
                               (
                                select ProductionDefectID from TP_PM_Defect where TP_PM_Defect.Productiondataid=:ProductionDataID
                               )";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":ProductionDataID",OracleDbType.Int32, productionDataID,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				ds.Tables[0].TableName = "TP_PM_ProductionData";
				DataSet ds2 = con.GetSqlResultToDs(sqlString2, paras);
				ds2.Tables[0].TableName = "TP_PM_Defect";
				DataSet ds3 = con.GetSqlResultToDs(sqlString3, paras);
				ds3.Tables[0].TableName = "TP_PM_DefectResponsible";
				DataSet ds4 = con.GetSqlResultToDs(sqlString4, paras);
				ds4.Tables[0].TableName = "TP_PM_DefectImage";

				DataSet ds5 = con.GetSqlResultToDs(sqlString5, paras);
				ds5.Tables[0].TableName = "TP_PM_DefectMissedResponsible";
				dsReturn.Tables.Add(ds.Tables[0].Copy());
				dsReturn.Tables.Add(ds2.Tables[0].Copy());
				dsReturn.Tables.Add(ds3.Tables[0].Copy());
				dsReturn.Tables.Add(ds4.Tables[0].Copy());
				dsReturn.Tables.Add(ds5.Tables[0].Copy());

				dsReturn.Tables["TP_PM_DefectImage"].Columns.Add("SourcePathByte", typeof(byte[]));
				for (int i = 0; i < dsReturn.Tables["TP_PM_DefectImage"].Rows.Count; i++)
				{
					string saveAllFilePath = AppDomain.CurrentDomain.BaseDirectory + dsReturn.Tables["TP_PM_DefectImage"].Rows[i]["ImagePath"].ToString();
					if (File.Exists(saveAllFilePath))
					{
						FileInfo file = new FileInfo(saveAllFilePath);
						Image PicImage = Image.FromStream(file.OpenRead());
						byte[] smallbuffer = null;
						using (MemoryStream ms = new MemoryStream())
						{
							PicImage.Save(ms, System.Drawing.Imaging.ImageFormat.Jpeg);
							ms.Position = 0;
							smallbuffer = new byte[ms.Length];
							ms.Read(smallbuffer, 0, Convert.ToInt32(ms.Length));
							ms.Flush();
						}
						dsReturn.Tables["TP_PM_DefectImage"].Rows[i]["SourcePathByte"] = smallbuffer;
					}
				}

				return dsReturn;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取产品完成工序的ID
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns>int</returns>
		public static int GetCompleteProcedureID(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                                    FlowProcedureID as 
                                    CompleteProcedureID,
                                    ProductionDataID,
                                    ProcedureID
                                    from TP_PM_InProduction
                                    where 
                                    TP_PM_InProduction.BarCode=:BarCode
                                    union
                                    select 
                                     FlowProcedureID as 
                                    CompleteProcedureID,
                                    ProductionDataID,
                                    ProcedureID
                                    from Tp_Pm_Inproductiontrash
                                    where 
                                    Tp_Pm_Inproductiontrash.BarCode=:BarCode
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					return Convert.ToInt32(ds.Tables[0].Rows[0]["CompleteProcedureID"]);
				}
				else
				{
					sqlString = @"select 
                                    BarCode
                                    from TP_PM_FinishedProduct
                                    where 
                                    TP_PM_FinishedProduct.BarCode=:BarCode
                                    ";
					paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
					};
					DataSet ds2 = con.GetSqlResultToDs(sqlString, paras);
					if (ds2 != null && ds2.Tables[0].Rows.Count > 0)
					{
						return -2;
					}
					else
					{
						return -1;
					}
				}
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 编辑后删除生产数据
		/// </summary>
		/// <param name="productionDataID">生产数据ID</param>
		/// <returns>int</returns>
		public static int DeleteProductionDataByID(int productionDataID)
		{
			int deleteRow = 0;
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				string sqlString5 = @"update TP_PM_DefectMissedResponsible set ValueFlag=0
                                   where TP_PM_DefectMissedResponsible.Productiondefectid in
                                   (
                                    select ProductionDefectID from TP_PM_Defect where TP_PM_Defect.Productiondataid=:ProductionDataID
                                   )";
				string sqlString4 = @"update  TP_PM_ProductionData  set ValueFlag=0
                                    where 
                                    TP_PM_ProductionData.Productiondataid=:ProductionDataID
                                    ";
				string sqlString3 = @"update TP_PM_Defect set ValueFlag=0
                                   where TP_PM_Defect.Productiondataid =:ProductionDataID";
				string sqlString2 = @"update TP_PM_DefectResponsible set ValueFlag=0
                                   where TP_PM_DefectResponsible.Productiondefectid in
                                   (
                                    select ProductionDefectID from TP_PM_Defect where TP_PM_Defect.Productiondataid=:ProductionDataID
                                   )";
				string sqlString = @"update  TP_PM_DefectImage set ValueFlag=0
                                   where TP_PM_DefectImage.Productiondefectid in
                                   (
                                    select ProductionDefectID from TP_PM_Defect where TP_PM_Defect.Productiondataid=:ProductionDataID
                                     )";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":ProductionDataID",OracleDbType.Int32, productionDataID,ParameterDirection.Input),
				};
				deleteRow += oracleTrConn.ExecuteNonQuery(sqlString, paras);
				deleteRow += oracleTrConn.ExecuteNonQuery(sqlString2, paras);
				deleteRow += oracleTrConn.ExecuteNonQuery(sqlString3, paras);
				deleteRow += oracleTrConn.ExecuteNonQuery(sqlString4, paras);
				deleteRow += oracleTrConn.ExecuteNonQuery(sqlString5, paras);
				// 没有错误 提交事务
				if (deleteRow > 0)
				{
					oracleTrConn.Commit();
				}
				else
				{
					oracleTrConn.Rollback();
				}
			}
			catch (Exception ex)
			{
				oracleTrConn.Rollback();
				throw ex;
			}
			finally
			{
				// 释放资源
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
			return deleteRow;
		}

		/// <summary>
		/// 由产品条码获取注浆信息
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns>DataSet</returns>
		public static DataSet GetGroutingProducttByBarCode(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                                    TP_PM_GroutingDailyDetail.UserCode as GroutingUserCode,
                                    TP_PM_GroutingDailyDetail.GroutingCount as GroutingNum,
                                    TP_PM_GroutingDailyDetail.GroutingMouldCode as MouldCode,
                                    TP_MST_Logo.logoid,
                                   TP_MST_Logo.logocode,
                                   TP_MST_Logo.logoname,
                                    (select tp_pm_inproduction.ispublicbody from 
                                     tp_pm_inproduction where tp_pm_inproduction.BarCode=:barcode) as ispublicbody,
                                     (select tp_pm_inproductiontrash.ispublicbody from 
                                     tp_pm_inproductiontrash where tp_pm_inproductiontrash.BarCode=:barcode) as ispublicbodyTrach,
                                    TP_PM_GroutingDailyDetail.Groutingdate
                                    from TP_PM_GroutingDailyDetail
                                    left join TP_MST_Logo
                                    on TP_PM_GroutingDailyDetail.logoid=TP_MST_Logo.logoid
                                    where TP_PM_GroutingDailyDetail.BarCode=:barcode";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":barcode",barcode),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据所选工号对应的工种，查出缺陷责任员工
		/// </summary>
		/// <param name="jobs">工种ID</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>DataSet</returns>
		public static DataSet GetDutyStaffByUserID(int jobs, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                             TP_HR_Staff.StaffID,TP_HR_Staff.StaffCode,TP_HR_Staff.StaffName,TP_HR_Staff.StaffStatus,TP_MST_UserStaff.UJobsID as SJobsID
                            from  TP_MST_UserStaff
                            left join TP_HR_Staff
                            on TP_MST_UserStaff.Staffid=TP_HR_Staff.Staffid
                            where TP_MST_UserStaff.Ujobsid=:jobs and TP_HR_Staff.StaffStatus in (1,2)
                            order by TP_HR_Staff.StaffCode
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":jobs",OracleDbType.Int32, jobs,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据所选工号，查出漏检责任员工
		/// </summary>
		/// <param name="userid">工号</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>DataSet</returns>
		public static DataSet GetMissedStaffByUserID(int userid, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                             TP_HR_Staff.StaffID,TP_HR_Staff.StaffCode,TP_HR_Staff.StaffName,TP_HR_Staff.StaffStatus,TP_MST_UserStaff.UJobsID as UJobsID,TP_HR_Staff.Jobs as SJobsID
                            from  TP_MST_UserStaff
                            left join TP_HR_Staff
                            on TP_MST_UserStaff.Staffid=TP_HR_Staff.Staffid
                            where TP_MST_UserStaff.Userid=:userid
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":userid",OracleDbType.Int32, userid,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 根据所选工号对应的工种，查出缺陷责任员工
		/// </summary>
		/// <param name="jobs">工种ID</param>
		/// <param name="userid">用户ID</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>DataSet</returns>
		public static DataSet GetDutyStaffByUserJobsID(int jobs, SUserInfo sUserInfo, int userid)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                             TP_HR_Staff.StaffID,TP_HR_Staff.StaffCode,TP_HR_Staff.StaffName,TP_HR_Staff.StaffStatus,TP_MST_UserStaff.UJobsID as SJobsID
                            from  TP_MST_UserStaff
                            left join TP_HR_Staff
                            on TP_MST_UserStaff.Staffid=TP_HR_Staff.Staffid
                            where TP_MST_UserStaff.Ujobsid=:jobs and  TP_MST_UserStaff.Userid=:userid
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":jobs",OracleDbType.Int32, jobs,ParameterDirection.Input),
					new OracleParameter(":userid",OracleDbType.Int32, userid,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取干补标识
		/// </summary>
		/// <param name="barcode">产品条码</param>ram>
		/// <returns>int</returns>
		public static int GetSpecialRepairflagByBarcode(string barcode, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                                    SpecialRepairflag
                                    from tp_pm_inproduction where barcode=:barcode
                                    union
                                    select
                                    SpecialRepairflag from 
                                     tp_pm_inproductiontrash where barcode=:barcode
                                     union
                                      select
                                    SpecialRepairflag from 
                                     tp_pm_finishedproduct where barcode=:barcode

                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					return Convert.ToInt32(ds.Tables[0].Rows[0]["SpecialRepairflag"]);
				}
				return 0;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取窑车对应产品列表
		/// <param name="KilnCarID">窑车ID</param>
		/// </summary>
		/// <returns>DataSet</returns>
		public static DataSet GetKilnCarGoodsByKilnCarID(int KilnCarID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select distinct
                                        TP_PM_KilnCarGoods.Barcode,
                                         TP_MST_Goods.Goodsid,
                                        TP_MST_Goods.Goodscode,
                                        TP_MST_Goods.Goodsname,
                                        TP_PM_KilnCarGoods.Userid,
                                        TP_PM_KilnCarGoods.Usercode,
                                        TP_PM_KilnCarGoods.Username,
                                        TP_MST_KilnCar.Kilncarname,
                                        TP_MST_KilnCar.Kilncarcode,
                                        TP_MST_Kiln.KilnName,
                                        TP_MST_Kiln.KilnCode,
                                        TP_MST_KilnCar.Kilnid,
                                        TP_MST_KilnCar.KilnCarid,
                                        TP_PM_KilnCarGoods.KilnCarPosition,
                                        TP_MST_DataDictionary.Dictionaryvalue,
                                        TP_PM_GroutingDailyDetail.UserCode as GroutingUserCode,
                                        TP_PM_GroutingDailyDetail.GroutingCount as GroutingNum,
                                        TP_PM_GroutingDailyDetail.GroutingMouldCode as MouldCode,
                                        (select max(tp_pm_inproduction.ispublicbody) from 
                                         tp_pm_inproduction where tp_pm_inproduction.BarCode=TP_PM_KilnCarGoods.Barcode) as ispublicbody,
                                        TP_PM_GroutingDailyDetail.Groutingdate,
                                        tp_mst_logo.logoid,
                                        tp_mst_logo.logocode,
                                        tp_mst_logo.logoname
                                        from 
                                        TP_PM_KilnCarGoods
                                        left join TP_MST_Goods
                                        on TP_PM_KilnCarGoods.Goodsid=TP_MST_Goods.Goodsid
                                        left join TP_MST_KilnCar
                                        on TP_PM_KilnCarGoods.Kilncarid=TP_MST_KilnCar.Kilncarid
                                        left join TP_MST_Kiln
                                        on TP_MST_KilnCar.Kilnid=TP_MST_Kiln.Kilnid
                                        left join TP_MST_DataDictionary
                                        on 	TP_PM_KilnCarGoods.KilnCarPosition=TP_MST_DataDictionary.Dictionaryid
                                        left join TP_PM_GroutingDailyDetail
                                        on TP_PM_KilnCarGoods.Barcode=TP_PM_GroutingDailyDetail.BarCode
                                        left join tp_mst_logo
                                        on TP_PM_GroutingDailyDetail.logoid=tp_mst_logo.logoid
                                        where TP_PM_KilnCarGoods.KilnCarID=:KilnCarID
                                    ";


				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":KilnCarID",OracleDbType.Int32, KilnCarID,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取未在生产线上报损的注浆信息
		/// <param name="barcode">产品条码</param>
		/// </summary>
		/// <returns>DataSet</returns>
		public static DataSet GetBarCodeInGroutingDailyDetail(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				// 首先查看条码是否有效
				string sqlString = @"select TP_PM_GroutingDailyDetail.GoodsID,TP_PM_GroutingDailyDetail.GoodsCode,TP_PM_GroutingDailyDetail.GoodsName
                                    ,TP_PM_GroutingDailyDetail.GroutingDailyID,TP_PM_GroutingDailyDetail.GroutingDailyDetailID
                                    ,TP_PM_GroutingDailyDetail.GroutingDate,TP_PM_GroutingDailyDetail.GroutingLineID,TP_PM_GroutingDailyDetail.GroutingLineCode
                                    ,TP_PM_GroutingDailyDetail.GroutingLineName
                                    ,TP_PM_GroutingDailyDetail.GroutingLineDetailID,TP_PM_GroutingDailyDetail.GroutingMouldCode,TP_PM_GroutingDailyDetail.MouldCode
                                    ,TP_PM_GroutingDailyDetail.UserID as GroutingUserID
                                    ,TP_PM_GroutingDailyDetail.UserCode as GroutingUserCode
                                    ,TP_PM_GroutingDailyDetail.GroutingCount as GroutingNum
                                    ,0 as IsPublicBody
                                    ,0 as IsReFire
                                    ,TP_PC_GroutingLine.GMouldTypeID
                                    ,TP_PM_GroutingDailyDetail.SpecialRepairFlag
                                    from TP_PM_GroutingDailyDetail 
                                    left join TP_PC_GroutingLine
                                    on TP_PM_GroutingDailyDetail.GroutingLineID=TP_PC_GroutingLine.GroutingLineID
                                    where TP_PM_GroutingDailyDetail.barcode=:barcode";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取编辑的生产数据ID与列表所选生产数据ID做比较
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns>int</returns>
		public static int GetCompleteProductionDataID(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                                    ProductionDataID
                                    from TP_PM_InProduction
                                    where 
                                    TP_PM_InProduction.BarCode=:BarCode
                                    union
                                    select
                                    ProductionDataID
                                    from Tp_Pm_Inproductiontrash
                                    where 
                                    Tp_Pm_Inproductiontrash.BarCode=:BarCode
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					return Convert.ToInt32(ds.Tables[0].Rows[0]["ProductionDataID"]);
				}
				else
				{
					return 0;
				}
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取在产产品的信息标识列表
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns>int</returns>
		public static DataSet GetInProductionDataList(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                                    BarCode,
                                    FlowProcedureID,
                                    FlowProcedureTime,
                                    ProcedureID,
                                    ProcedureTime,
                                    ProductionDataID,
                                    IsReFire,
                                    SpecialRepairFlag
                                    from TP_PM_InProduction
                                    where 
                                    TP_PM_InProduction.BarCode=:BarCode
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 成检时获取此条码是否报损
		/// <param name="barcode">产品条码</param>
		/// </summary>
		/// <returns>int</returns>
		public static int CheckScrapProduct(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select auditstatus from tp_pm_scrapproduct where auditstatus in(0,1) and valueflag=1 and goodsleveltypeid=8 and barcode=:barcode and recyclingflag=0";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					return Convert.ToInt32(ds.Tables[0].Rows[0]["auditstatus"]);
				}
				return -100;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取产品完成工序的ID(PDA)
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns>int</returns>
		public static DataSet GetCompleteProcedureIDPDA(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                                    FlowProcedureID as 
                                    CompleteProcedureID,
                                    ProductionDataID,
                                    ProcedureID,
                                    OPTimeStamp,
                                    to_char(OPTimeStamp,'DD-MM-YYHH12.MI.SS.FFAM') as ConvertOPTimeStamp
                                    from TP_PM_InProduction
                                    where 
                                    TP_PM_InProduction.BarCode=:BarCode
                                    union
                                    select 
                                     FlowProcedureID as 
                                    CompleteProcedureID,
                                    ProductionDataID,
                                    ProcedureID,
                                    OPTimeStamp,
                                    to_char(OPTimeStamp,'DD-MM-YYHH12.MI.SS.FFAM') as ConvertOPTimeStamp
                                    from Tp_Pm_Inproductiontrash
                                    where 
                                    Tp_Pm_Inproductiontrash.BarCode=:BarCode
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 成检时获取条码的产品信息（成检(正品)--报损-->干补-->成检）
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns>int</returns>
		public static DataSet GetGoodsInfoBybarcode(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                                    GoodsID,GoodsCode,GoodsName,
                                     (
                                    select 
                                    TP_PM_InProduction.SpecialRepairFlag
                                    from TP_PM_InProduction
                                    where TP_PM_InProduction.BarCode=:BarCode
                                    ) SpecialRepairFlag,
                                     (
                                    select 
                                    TP_PM_InProduction.IsReFire
                                    from TP_PM_InProduction
                                    where TP_PM_InProduction.BarCode=:BarCode
                                    ) IsReFire,
                                    tp_mst_logo.logoid,
                                    tp_mst_logo.logocode,
                                    tp_mst_logo.logoname,
                                    TP_PM_GroutingDailyDetail.UserCode,
                                    TP_PM_GroutingDailyDetail.GroutingMouldCode as MouldCode,
                                    TP_PM_GroutingDailyDetail.GroutingCount,
                                    TP_PM_GroutingDailyDetail.GroutingDate
                                    from TP_PM_GroutingDailyDetail
                                    left join tp_mst_logo
                                    on TP_PM_GroutingDailyDetail.logoid=tp_mst_logo.logoid
                                    where 
                                    TP_PM_GroutingDailyDetail.BarCode=:BarCode
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 生成盘点明细
		/// </summary>
		/// <param name="ProcedureIDS">工序ID集</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns></returns>
		public static DataSet GetInCheckedDetail(string ProcedureIDS, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                                    TP_PM_InProduction.BarCode,
                                    TP_PM_InProduction.ProductionLineID,
                                    TP_PM_InProduction.ProductionLineCode,
                                    TP_PM_InProduction.ProductionLineName,
                                    TP_PM_InProduction.FlowProcedureID,
                                    TP_PM_InProduction.ProcedureID,
                                    TP_PM_InProduction.ProcedureModel,
                                    TP_PM_InProduction.ModelType,
                                    TP_PM_InProduction.GoodsID,
                                    TP_PM_InProduction.GoodsCode,
                                    TP_PM_InProduction.GoodsName,
                                    TP_PM_InProduction.GroutingDate,
                                    TP_PM_InProduction.GroutingLineCode,
                                    TP_PM_InProduction.GroutingLineName,
                                    TP_PM_InProduction.GroutingMouldCode,
                                    TP_PM_InProduction.GroutingUserCode,
                                    TP_PM_InProduction.GroutingNum,
                                    TP_PM_InProduction.KilnCode,
                                    TP_PM_InProduction.KilnName,
                                    TP_PM_InProduction.KilnCarCode,
                                    TP_PM_InProduction.KilnCarName,
                                    TP_PM_InProduction.IsPublicBody,
                                    TP_PM_InProduction.IsReFire,
                                    TP_PM_InProduction.SpecialRepairFlag,
                                    TP_PC_Procedure.ProcedureName
                                    from TP_PM_InProduction
                                    left join TP_PC_Procedure
                                    on  TP_PM_InProduction.FlowProcedureID=TP_PC_Procedure.ProcedureID where TP_PM_InProduction.accountid=:accountid
                                    ";
				List<OracleParameter> parameters = new List<OracleParameter>();
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, sUserInfo.AccountID, ParameterDirection.Input));
				// 工序IDS
				if (!string.IsNullOrEmpty(ProcedureIDS))
				{
					sqlString += "AND instr(','||:ProcedureIDS||',',','||TP_PM_InProduction.FlowProcedureID||',')>0 ";
					parameters.Add(new OracleParameter(":ProcedureIDS", OracleDbType.NVarchar2, ProcedureIDS, ParameterDirection.Input));
				}
				DataSet ds = con.GetSqlResultToDs(sqlString, parameters.ToArray());
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取盘点单列表
		/// </summary>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static DataSet GetInCheckedList(SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select InCheckedID,InCheckedNo,AccountDate from TP_PM_InChecked where accountid=:accountid and ValueFlag=1";
				List<OracleParameter> parameters = new List<OracleParameter>();
				parameters.Add(new OracleParameter(":accountid", OracleDbType.Int32, sUserInfo.AccountID, ParameterDirection.Input));
				DataSet ds = con.GetSqlResultToDs(sqlString, parameters.ToArray());
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取盘点单工号列表
		/// </summary>
		/// <param name="sUserInfo"></param>
		/// <returns></returns>
		public static DataSet GetInCheckedUserList(int InCheckedID, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select tp_pm_incheckeduser.InCheckedID,tp_pm_incheckeduser.UserID,tp_pm_incheckeduser.UserCode,
                                        tp_mst_user.UserName     from tp_pm_incheckeduser 
                                    left join tp_mst_user on tp_pm_incheckeduser.userid=tp_mst_user.userid
                                    where tp_pm_incheckeduser.InCheckedID=:InCheckedID";
				List<OracleParameter> parameters = new List<OracleParameter>();
				parameters.Add(new OracleParameter(":InCheckedID", OracleDbType.Int32, InCheckedID, ParameterDirection.Input));
				DataSet ds = con.GetSqlResultToDs(sqlString, parameters.ToArray());
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取主表盘点信息
		/// </summary>
		/// <param name="entity">盘点类</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns></returns>
		public static DataSet GetAllInChecked(InCheckedEntity entity, SUserInfo sUserInfo)
		{

			IDBConnection oracleConn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleConn.Open();
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter("in_inCheckedNo",OracleDbType.NVarchar2, entity.InCheckedNo,ParameterDirection.Input),
					new OracleParameter("in_inCheckedName",OracleDbType.NVarchar2, entity.InCheckedName,ParameterDirection.Input),
					new OracleParameter("in_remarks",OracleDbType.NVarchar2, entity.Remarks,ParameterDirection.Input),
					new OracleParameter("in_begindate",OracleDbType.Date, entity.BeginDate,ParameterDirection.Input),
					new OracleParameter("in_enddate",OracleDbType.Date,entity.EndDate,ParameterDirection.Input),
					new OracleParameter("out_result",OracleDbType.RefCursor, ParameterDirection.Output),
					new OracleParameter("in_accountID",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter("in_userID",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
				};
				DataSet returnDataSet = oracleConn.ExecStoredProcedure("PRO_PM_GetInChecked", paras);
				return returnDataSet;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (oracleConn.ConnState == ConnectionState.Open)
				{
					oracleConn.Close();
				}
			}
		}

		/// <summary>
		/// 获取盘点单名细信息
		/// </summary>
		/// <param name="InCheckedID">盘点单号</param>
		/// <returns></returns>
		public static DataSet GetAllInCheckedDetail(int inCheckedID)
		{
			IDBConnection oracleConn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleConn.Open();
				string sql = @"select 
                                TP_PM_InCheckedDetail.InCheckedID,
                                0 as Sel,
                                TP_PM_InCheckedDetail.BarCode,
                                TP_PM_InCheckedDetail.InCheckedNo,
                                TP_PM_InCheckedDetail.ProductionLineCode,
                                TP_PM_InCheckedDetail.ProductionLineName,
                                TP_PC_Procedure.ProcedureName,
                                decode(TP_PM_InCheckedDetail.ProcedureModel, '1', '计件模型' , '检验模型') as ProcedureModel,
                                decode(TP_PM_InCheckedDetail.DefectFlag, '1', '无缺陷' , '有缺陷') as DefectFlag,
                                TP_PM_InCheckedDetail.IsPublicBody,
                                TP_PM_InCheckedDetail.IsReFire,
                                TP_PM_InCheckedDetail.SpecialRepairFlag,
                                TP_PM_InCheckedDetail.GoodsCode,
                                TP_PM_InCheckedDetail.GoodsName,
                                TP_PM_InCheckedDetail.GroutingDate,
                                TP_PM_InCheckedDetail.GroutingLineCode,
                                TP_PM_InCheckedDetail.GroutingLineName,
                                TP_PM_InCheckedDetail.GroutingMouldCode,
                                TP_PM_InCheckedDetail.GroutingUserCode,
                                TP_PM_InCheckedDetail.GroutingNum,
                                TP_PM_InCheckedDetail.KilnCode,
                                TP_PM_InCheckedDetail.KilnName,
                                TP_PM_InCheckedDetail.KilnCarCode,
                                TP_PM_InCheckedDetail.KilnCarName,
                                decode(TP_PM_InCheckedDetail.InCheckedFlag, '0', '未盘点' , '1','已盘点','盘盈') as InCheckedFlagName,
                                TP_PM_InCheckedDetail.InCheckedFlag,
                                TP_PM_InCheckedDetail.CheckedDate,
                                Tp_mst_user.usercode CheckedUserCode,
                                u.usercode,
                                inpu.usercode cusercode,
                                TP_PM_InCheckedDetail.ProcedureTime,
                                TP_PM_InCheckedDetail.IsReworkFlag,
                                TP_PM_InCheckedDetail.InScrapFlag,
                                decode(sp.SCRAPPRODUCTID, null, 0, 1) SCRAPPRODUCTID,
                                su.usercode susercode,
                                spin.CREATETIME sdatetime,
                                decode(spin.AUDITSTATUS,1, au.usercode , null) ausercode,
                                spin.AUDITDATE adatetime,gt.goodstypename
                                  --,inpp.procedurename currentprocedurename
                                  --,inp.proceduretime currentproceduretime" + "\n" +
				"      ,case when inp.barcode is not null then to_char(inpp.procedurename) " +
				"            when sp.barcode is not null then to_char(glt.goodsleveltypename) " +
				"            when fp.barcode is not null then '生产完成' else '' end currentprocedurename -- 当前工序\n" +
				"      ,case when inp.barcode is not null then inp.PROCEDURETIME " +
				"            when sp.barcode is not null then sp.auditdate " +
				"            when fp.barcode is not null then fp.createtime else null end currentproceduretime -- 当前工序时间\n" +
								@"from TP_PM_InCheckedDetail
                                left join tp_mst_goods g on TP_PM_InCheckedDetail.goodsid = g.goodsid
                                left join tp_mst_goodstype gt on gt.goodstypeid = g.goodstypeid
                                left join TP_PC_Procedure
                                on  TP_PM_InCheckedDetail.ProcedureID=TP_PC_Procedure.ProcedureID
                                left join Tp_mst_user
                                on TP_PM_InCheckedDetail.CheckedUserID=Tp_mst_user.userid
                                left join Tp_mst_user u
                                on TP_PM_InCheckedDetail.UserID=u.userid
                                left join TP_PM_SCRAPPRODUCT spin
                               -- on spin.barcode = TP_PM_InCheckedDetail.BarCode
                                on spin.groutingdailydetailid = TP_PM_InCheckedDetail.groutingdailydetailid
                                and spin.GOODSLEVELTYPEID = 8 and spin.AUDITSTATUS in (0,1)
                                and spin.valueflag = '1' and spin.RECYCLINGFLAG = '0'
                                left join Tp_mst_user su on su.userid = spin.CREATEUSERID
                                left join Tp_mst_user au on au.userid = spin.AUDITOR
                                  LEFT JOIN Tp_Pm_Inproduction inp
                                    --ON inp.barcode = TP_PM_InCheckedDetail.Barcode
                                    ON inp.groutingdailydetailid = TP_PM_InCheckedDetail.groutingdailydetailid" +
				// 完成 groutingdailydetailid
				"  LEFT JOIN tp_pm_finishedproduct fp \n" +
				//"    ON inp.barcode is null and fp.barcode = TP_PM_InCheckedDetail.barcode\n" +
				"    ON inp.barcode is null and fp.groutingdailydetailid = TP_PM_InCheckedDetail.groutingdailydetailid\n" +
				// 损坯
				"  LEFT JOIN  tp_pm_scrapproduct sp \n" +
				//"    ON inp.barcode is null and fp.barcode is null and sp.barcode = TP_PM_InCheckedDetail.barcode\n" +
				"    ON inp.barcode is null and fp.barcode is null and sp.groutingdailydetailid = TP_PM_InCheckedDetail.groutingdailydetailid\n" +
				"   AND sp.valueflag = '1'\n" +
				"   AND sp.auditstatus = 1\n" +
				"   AND sp.goodsleveltypeid <> 9\n" +
				"   AND sp.RECYCLINGFLAG = '0'\n" +
				"  LEFT JOIN  tp_sys_goodsleveltype glt \n" +
				"    ON glt.goodsleveltypeid = sp.goodsleveltypeid\n" +

								@"LEFT JOIN tp_pc_procedure inpp
                                    ON inpp.procedureid = inp.procedureid
                                left join Tp_mst_user inpu
                                on inp.UserID=inpu.userid
                                where InCheckedID=:InCheckedID and TP_PM_InCheckedDetail.valueflag=1 and TP_PM_InCheckedDetail.InCheckedFlag = :InCheckedFlag
                                ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":InCheckedFlag",OracleDbType.Int32,(int)Constant.InCheckedFlag.InCheckedNo,ParameterDirection.Input),
					new OracleParameter(":InCheckedID",OracleDbType.Int32,inCheckedID,ParameterDirection.Input),
				};
				DataSet returnDataSet = oracleConn.GetSqlResultToDs(sql, paras);

				paras[0].Value = (int)Constant.InCheckedFlag.InCheckeded;
				returnDataSet.Tables.Add(oracleConn.GetSqlResultToDt(sql, paras));

				paras[0].Value = (int)Constant.InCheckedFlag.InCheckedWin;
				returnDataSet.Tables.Add(oracleConn.GetSqlResultToDt(sql, paras));

				sql = @"select tp_pm_incheckeduser.InCheckedID,tp_pm_incheckeduser.UserID,tp_pm_incheckeduser.UserCode,
                                        tp_mst_user.UserName     from tp_pm_incheckeduser 
                                    left join tp_mst_user on tp_pm_incheckeduser.userid=tp_mst_user.userid
                                    where tp_pm_incheckeduser.InCheckedID=:InCheckedID";
				paras = new OracleParameter[]{
					new OracleParameter(":InCheckedID",OracleDbType.Int32,inCheckedID,ParameterDirection.Input),
				};
				DataTable userTable = oracleConn.GetSqlResultToDt(sql, paras);
				userTable.TableName = "UserTable";
				returnDataSet.Tables.Add(userTable);
				return returnDataSet;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (oracleConn.ConnState == ConnectionState.Open)
				{
					oracleConn.Close();
				}
			}
		}



		/// <summary>
		/// 获取盘点单名细信息
		/// </summary>
		/// <param name="InCheckedID">盘点单号</param>
		/// <returns></returns>
		public static DataSet GetGroutingInfoBybarcode(string barcode, SUserInfo sUserInfo)
		{
			IDBConnection oracleConn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleConn.Open();
				// Flowprocedureid 换成 procedureid,干补特殊，会不一样，别的都一样
				string sql = @"select
                                gdd.barcode,
                                gdd.GoodsCode,
                                 gdd.UserCode,
                                 gdd.GroutingDate,
                                 gdd.GroutingMouldCode,
                                logo.logoname -- 商标
                                --,g.MaterialCode || logo.TagCode || gdd.OnlyCode OutOnlyCode -- 外包装唯一码
                                ,nvl(gdd.outlabelcode, g.MaterialCode || (select a.workcode from tp_mst_account a where a.accountid = gdd.accountid) || logo.TagCode || gdd.OnlyCode) OutOnlyCode
                                ,tp_pc_procedure.procedurename
                                from TP_PM_GroutingDailyDetail gdd
                                INNER JOIN tp_mst_goods g
                                        ON g.goodsid = gdd.goodsid
                                LEFT JOIN tp_mst_logo logo
                                  ON logo.logoid = gdd.logoid
                                left join TP_PM_InProduction
                                on gdd.barcode=TP_PM_InProduction.barcode
                                left join tp_pc_procedure 
                                on TP_PM_InProduction.procedureid=tp_pc_procedure.procedureid
                                where gdd.barcode=FUN_CMN_GetBarCode(:barcode,null,:accountid) and gdd.valueflag=1 and gdd.scrapflag=0
                                ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.Varchar2,barcode,ParameterDirection.Input),
					 new OracleParameter(":accountid",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
				};
				DataSet returnDataSet = oracleConn.GetSqlResultToDs(sql, paras);
				return returnDataSet;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (oracleConn.ConnState == ConnectionState.Open)
				{
					oracleConn.Close();
				}
			}
		}



		/// <summary>
		/// 获取盘点单名细信息
		/// </summary>
		/// <param name="InCheckedID">盘点单号</param>
		/// <returns></returns>
		public static DataSet GetFinishedProductGroutingInfoBybarcode(string barcode, SUserInfo sUserInfo)
		{
			IDBConnection oracleConn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleConn.Open();
				string sql = @"select 
                                gdd.barcode,
                                gdd.GoodsCode,
                                 gdd.UserCode,
                                 gdd.GroutingDate,
                                 gdd.GroutingMouldCode,
                                logo.logoname -- 商标
                                --,g.MaterialCode || logo.TagCode || gdd.OnlyCode OutOnlyCode -- 外包装唯一码
                                ,nvl(gdd.outlabelcode, g.MaterialCode || (select a.workcode from tp_mst_account a where a.accountid = gdd.accountid) || logo.TagCode || gdd.OnlyCode) OutOnlyCode
                                ,tp_pc_procedure.procedurename
                                from TP_PM_GroutingDailyDetail gdd
                                INNER JOIN tp_mst_goods g
                                        ON g.goodsid = gdd.goodsid
                                LEFT JOIN tp_mst_logo logo
                                  ON logo.logoid = gdd.logoid
                                left join TP_PM_InProduction
                                on gdd.barcode=TP_PM_InProduction.barcode
                                left join tp_pc_procedure 
                                on TP_PM_InProduction.Flowprocedureid=tp_pc_procedure.procedureid
                                where gdd.barcode=FUN_CMN_GetBarCode(:barcode,null,:accountid) and gdd.valueflag=1 and gdd.scrapflag=0
                                ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.Varchar2,barcode,ParameterDirection.Input),
					 new OracleParameter(":accountid",OracleDbType.Int32,sUserInfo.AccountID,ParameterDirection.Input),
				};
				DataSet returnDataSet = oracleConn.GetSqlResultToDs(sql, paras);
				return returnDataSet;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (oracleConn.ConnState == ConnectionState.Open)
				{
					oracleConn.Close();
				}
			}
		}

		#region 清除在产残留数据

		/// <summary>
		/// 取得PM2108画面（在产品明细表）的查询数据
		/// </summary>
		/// <param name="user">登录用户信息</param>
		/// <param name="se">查询条件</param>
		/// <returns>查询结果</returns>
		public static ServiceResultEntity GetPM2108Data(SUserInfo user, RPT010401_SE se)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);

				List<OracleParameter> parameters = new List<OracleParameter>();
				StringBuilder sql = new StringBuilder(PMModuleLogic.GetRPT010401SSQL());
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));

				sql.Append("  and TP_PM_InProduction.modeltype not in (1,2,3) ");

				if (se != null)
				{
					//生产线IDS
					if (!string.IsNullOrEmpty(se.ProductionLineIDS))
					{
						sql.Append("  AND instr(','||:ProductionLineIDS||',',','||TP_PM_InProduction.ProductionLineID||',')>0 ");
						parameters.Add(new OracleParameter(":ProductionLineIDS", OracleDbType.NVarchar2, se.ProductionLineIDS, ParameterDirection.Input));
					}

					//完成工序IDS
					if (!string.IsNullOrEmpty(se.ProcedureIDS))
					{
						sql.Append("  AND instr(','||:ProcedureIDS||',',','||TP_PM_InProduction.ProcedureID||',')>0 ");
						parameters.Add(new OracleParameter(":ProcedureIDS", OracleDbType.NVarchar2, se.ProcedureIDS, ParameterDirection.Input));
					}


					// 生产时间--开始
					if (se.UpdateTimeStart.HasValue)
					{
						sql.Append("  AND TP_PM_InProduction.Proceduretime >= :UpdateTimeStart ");
						parameters.Add(new OracleParameter(":UpdateTimeStart", OracleDbType.Date, se.UpdateTimeStart.Value, ParameterDirection.Input));
					}

					// 生产时间--结束
					if (se.UpdateTimeEnd.HasValue)
					{
						sql.Append("  AND TP_PM_InProduction.Proceduretime <= :UpdateTimeEnd ");
						parameters.Add(new OracleParameter(":UpdateTimeEnd", OracleDbType.Date, se.UpdateTimeEnd.Value, ParameterDirection.Input));
					}

					//产品条码
					if (!string.IsNullOrEmpty(se.Barcode))
					{
						sql.Append("  AND instr(TP_PM_InProduction.barcode,:barcode)>0 ");
						parameters.Add(new OracleParameter(":barcode", OracleDbType.NVarchar2, se.Barcode, ParameterDirection.Input));
					}
					sql.Append("  AND TP_PM_InProduction.inscrapflag=0  ");

				}
				sql.Append("  order by TP_PM_InProduction.UpdateTime desc");
				DataTable data = conn.GetSqlResultToDt(sql.ToString(), parameters.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}

		/// <summary>
		/// 获取RPT010401画面（在产品明细表）的查询sql
		/// </summary>
		/// <returns>sql</returns>
		private static string GetRPT010401SSQL()
		{
			string selSql =
					"SELECT 0 as Sel," +
					"  TP_PM_InProduction.BarCode, " +
					"  TP_PM_InProduction.GoodsID,TP_PM_InProduction.GoodsCode, " +
					"  TP_PM_InProduction.GoodsName, " +
					"  TP_PM_InProduction.Userid,A.USERNAME as UserName,A.USERCode as UserCode, " +
					"  TP_PM_InProduction.ProductionLineID, " +
					"  TP_PM_InProduction.ProductionLineCode, " +
					"  TP_PM_InProduction.ProductionLineName, " +
					"  TP_PM_InProduction.ModelType, " +
					"  decode(TP_PM_InProduction.inscrapflag , '1', '待审核的报废品' , '正常') as inscrapflag, " +
					//"  decode(TP_PM_InProduction.IsPublicBody, '1', '是' , '否') as IsPublicBody, " +
					//"  decode(TP_PM_InProduction.IsReFire, '1', '是' , '否') as IsReFire, " +
					"  TP_PM_InProduction.IsPublicBody, " +
					"  TP_PM_InProduction.IsReFire, " +
					"  decode(TP_PM_InProduction.CanManyTimes, '1', '能' , '不能') as CanManyTimes, " +
					"  decode(TP_PM_InProduction.ProcedureModel, '1', '计件模型' , '检验模型') as ProcedureModel, " +
					"  TP_PM_InProduction.GroutingDailyID, " +
					"  TP_PM_InProduction.GroutingDailyDetailID, " +
					"  TP_PM_InProduction.GroutingDate, " +
					"  TP_PM_InProduction.GroutingLineID, " +
					"  TP_PM_InProduction.GroutingLineCode, " +
					"  TP_PM_InProduction.GroutingLineName, " +
					"  TP_PM_InProduction.ProcedureID CompleteProcedureID, " +
					"  D.ProcedureName as CompleteProcedureName, " +
					"  TP_PM_InProduction.GMouldTypeID, " +
					"  TP_MST_GMouldType.GMOULDTYPENAME as GMouldTypeName, " +
					"  TP_PM_InProduction.GroutingLineDetailID, " +
					"  TP_PM_InProduction.GroutingMouldCode, " +
					"  TP_PM_InProduction.SPECIALREPAIRFLAG, " +
					"  TP_PM_InProduction.GROUTINGUSERCODE, " +
					"  TP_PM_GroutingDailyDetail.GROUTINGCOUNT, " +
					"  TP_PM_InProduction.Remarks, " +
					"  TP_PM_InProduction.GoodsLevelID,TP_MST_GoodsLevel.GOODSLEVELNAME, " +
					"  TP_PM_InProduction.GoodsLevelTypeID,TP_SYS_GoodsLevelType.GOODSLEVELTYPENAME, " +
					"  TP_PM_InProduction.AccountID,TP_PM_InProduction.ValueFlag, " +
					"  TP_PM_InProduction.CreateTime,TP_PM_InProduction.CreateUserID,B.USERNAME as CreateUserName, " +
					"  TP_PM_InProduction.PROCEDURETIME AS UpdateTime,TP_PM_InProduction.UpdateUserID,C.USERNAME as UpdateUserName, " +
				   "   TP_PM_InProduction.IsReworkFlag " +
					"FROM TP_PM_InProduction " +
					"  inner join TP_MST_User A on A.UserID=TP_PM_InProduction.Userid " +
					"  inner join TP_MST_User B on B.UserID=TP_PM_InProduction.CreateUserID " +
					"  inner join TP_MST_User C on C.UserID=TP_PM_InProduction.UpdateUserID " +
					"  inner join TP_PC_Procedure D on D.PROCEDUREID=TP_PM_InProduction.ProcedureID " +
					"  inner join TP_MST_GMouldType on TP_MST_GMouldType.GMouldTypeID=TP_PM_InProduction.GMouldTypeID " +
					"  inner join TP_SYS_ProcedureModelType on TP_SYS_ProcedureModelType.ProcedureModelTypeID=TP_PM_InProduction.ModelType " +
					"  inner join TP_PM_GroutingDaily on TP_PM_GroutingDaily.GroutingDailyID=TP_PM_InProduction.GroutingDailyID " +
					"  inner join TP_PM_GroutingDailyDetail on TP_PM_GroutingDailyDetail.Groutingdailydetailid=TP_PM_InProduction.GroutingDailyDetailID " +
					"  inner join TP_PC_GroutingLineDetail on TP_PC_GroutingLineDetail.Groutinglinedetailid=TP_PM_InProduction.GroutingLineDetailID " +
					"  inner join TP_MST_Account on TP_MST_Account.Accountid=TP_PM_InProduction.Accountid " +
					"  left join TP_MST_GoodsLevel on TP_MST_GoodsLevel.GoodsLevelID=TP_PM_InProduction.GoodsLevelID " +
					"  left join TP_SYS_GoodsLevelType on TP_SYS_GoodsLevelType.GoodsLevelTypeID=TP_PM_InProduction.GoodsLevelTypeID " +
					"  Where 1=1 and  TP_PM_InProduction.ValueFlag = 1 " +
					"  and TP_PM_InProduction.AccountID=:AccountID ";

			return selSql;
		}

		#endregion

		#region 清除在产回收站数据

		public static ServiceResultEntity GetPM2110Data(SUserInfo user, FPM2110_SE se)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);

				List<OracleParameter> parameters = new List<OracleParameter>();
				StringBuilder sql = new StringBuilder(PMModuleLogic.GetPM2110SQL());
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));

				if (se != null)
				{
					//生产线IDS
					if (!string.IsNullOrEmpty(se.ProductionLineIDS))
					{
						sql.Append("  AND instr(','||:ProductionLineIDS||',',','||Tp_Pm_Inproductiontrash.ProductionLineID||',')>0 ");
						parameters.Add(new OracleParameter(":ProductionLineIDS", OracleDbType.NVarchar2, se.ProductionLineIDS, ParameterDirection.Input));
					}

					//完成工序IDS
					if (!string.IsNullOrEmpty(se.ProcedureIDS))
					{
						sql.Append("  AND instr(','||:ProcedureIDS||',',','||Tp_Pm_Inproductiontrash.ProcedureID||',')>0 ");
						parameters.Add(new OracleParameter(":ProcedureIDS", OracleDbType.NVarchar2, se.ProcedureIDS, ParameterDirection.Input));
					}


					// 生产时间--开始
					if (se.UpdateTimeStart.HasValue)
					{
						sql.Append("  AND Tp_Pm_Inproductiontrash.Proceduretime >= :UpdateTimeStart ");
						parameters.Add(new OracleParameter(":UpdateTimeStart", OracleDbType.Date, se.UpdateTimeStart.Value, ParameterDirection.Input));
					}

					// 生产时间--结束
					if (se.UpdateTimeEnd.HasValue)
					{
						sql.Append("  AND Tp_Pm_Inproductiontrash.Proceduretime <= :UpdateTimeEnd ");
						parameters.Add(new OracleParameter(":UpdateTimeEnd", OracleDbType.Date, se.UpdateTimeEnd.Value, ParameterDirection.Input));
					}

					//报废日期开始
					if (se.ScrapDataStart.HasValue)
					{
						sql.Append("  AND TP_PM_SCRAPPRODUCT.SCRAPDATE >= trunc(:ScrapDateStart) ");
						parameters.Add(new OracleParameter(":ScrapDateStart", OracleDbType.Date, se.ScrapDataStart.Value, ParameterDirection.Input));
					}

					//报废日期结束
					if (se.ScrapDataEnd.HasValue)
					{
						sql.Append("  AND TP_PM_SCRAPPRODUCT.SCRAPDATE <= trunc(:ScrapDateEnd)");
						parameters.Add(new OracleParameter(":ScrapDateEnd", OracleDbType.Date, se.ScrapDataEnd.Value, ParameterDirection.Input));
					}

					//产品条码
					if (!string.IsNullOrEmpty(se.Barcode))
					{
						sql.Append("  AND instr(Tp_Pm_Inproductiontrash.barcode,:barcode)>0 ");
						parameters.Add(new OracleParameter(":barcode", OracleDbType.NVarchar2, se.Barcode, ParameterDirection.Input));
					}

					// 产品分级
					sql.Append("  AND TP_PM_SCRAPPRODUCT.GOODSLEVELTYPEID = :GooddLevelTypeID ");
					parameters.Add(new OracleParameter(":GooddLevelTypeID", OracleDbType.Int32, se.GooddLevelTypeID, ParameterDirection.Input));
				}
				sql.Append("  order by Tp_Pm_Inproductiontrash.UpdateTime desc");
				DataTable data = conn.GetSqlResultToDt(sql.ToString(), parameters.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}


		/// <summary>
		/// 获取RPT010401画面（在产品明细表）的查询sql
		/// </summary>
		/// <returns>sql</returns>
		private static string GetPM2110SQL()
		{
			string selSql =
				@"SELECT 0 as Sel,
                       Tp_Pm_Inproductiontrash.BarCode,
                       Tp_Pm_Inproductiontrash.GoodsID,
                       Tp_Pm_Inproductiontrash.GoodsCode,
                       Tp_Pm_Inproductiontrash.GoodsName,
                       Tp_Pm_Inproductiontrash.Userid,
                       A.USERNAME as UserName,
                       A.USERCode as UserCode,
                       Tp_Pm_Inproductiontrash.ProductionLineID,
                       Tp_Pm_Inproductiontrash.ProductionLineCode,
                       Tp_Pm_Inproductiontrash.ProductionLineName,
                       Tp_Pm_Inproductiontrash.ModelType,
                       --decode(Tp_Pm_Inproductiontrash.IsPublicBody, '1', '是', '否') as IsPublicBody,
                       --decode(Tp_Pm_Inproductiontrash.IsReFire, '1', '是', '否') as IsReFire,
                       Tp_Pm_Inproductiontrash.IsPublicBody,
                       Tp_Pm_Inproductiontrash.IsReFire,
                       decode(Tp_Pm_Inproductiontrash.CanManyTimes, '1', '能', '不能') as CanManyTimes,
                       decode(Tp_Pm_Inproductiontrash.ProcedureModel,
                              '1',
                              '计件模型',
                              '检验模型') as ProcedureModel,
                       Tp_Pm_Inproductiontrash.GroutingDailyID,
                       Tp_Pm_Inproductiontrash.GroutingDailyDetailID,
                       Tp_Pm_Inproductiontrash.GroutingDate,
                       Tp_Pm_Inproductiontrash.GroutingLineID,
                       Tp_Pm_Inproductiontrash.GroutingLineCode,
                       Tp_Pm_Inproductiontrash.GroutingLineName,
                       Tp_Pm_Inproductiontrash.ProcedureID CompleteProcedureID,
                       D.ProcedureName as CompleteProcedureName,
                       Tp_Pm_Inproductiontrash.GMouldTypeID,
                       TP_MST_GMouldType.GMOULDTYPENAME as GMouldTypeName,
                       Tp_Pm_Inproductiontrash.GroutingLineDetailID,
                       Tp_Pm_Inproductiontrash.GroutingMouldCode,
                       Tp_Pm_Inproductiontrash.SPECIALREPAIRFLAG,
                       Tp_Pm_Inproductiontrash.GROUTINGUSERCODE,
                       TP_PM_GroutingDailyDetail.GROUTINGCOUNT,
                       Tp_Pm_Inproductiontrash.Remarks,
                       Tp_Pm_Inproductiontrash.GoodsLevelID,
                       TP_MST_GoodsLevel.GOODSLEVELNAME,
                       Tp_Pm_Inproductiontrash.GoodsLevelTypeID,
                       TP_SYS_GoodsLevelType.GOODSLEVELTYPENAME,
                       Tp_Pm_Inproductiontrash.AccountID,
                       Tp_Pm_Inproductiontrash.ValueFlag,
                       Tp_Pm_Inproductiontrash.CreateTime,
                       Tp_Pm_Inproductiontrash.CreateUserID,
                       B.USERNAME as CreateUserName,
                       Tp_Pm_Inproductiontrash.PROCEDURETIME AS UpdateTime,
                       Tp_Pm_Inproductiontrash.UpdateUserID,
                       C.USERNAME as UpdateUserName
                  FROM Tp_Pm_Inproductiontrash
                 inner join TP_MST_User A on A.UserID = Tp_Pm_Inproductiontrash.Userid
                 inner join TP_MST_User B on B.UserID = Tp_Pm_Inproductiontrash.CreateUserID
                 inner join TP_MST_User C on C.UserID = Tp_Pm_Inproductiontrash.UpdateUserID
                 inner join TP_PC_Procedure D on D.PROCEDUREID =
                                                 Tp_Pm_Inproductiontrash.ProcedureID
                 inner join TP_MST_GMouldType on TP_MST_GMouldType.GMouldTypeID =
                                                 Tp_Pm_Inproductiontrash.GMouldTypeID
                 inner join TP_PM_GroutingDaily on TP_PM_GroutingDaily.GroutingDailyID =
                                                   Tp_Pm_Inproductiontrash.GroutingDailyID
                 inner join TP_PM_GroutingDailyDetail on TP_PM_GroutingDailyDetail.Groutingdailydetailid =
                                                         Tp_Pm_Inproductiontrash.GroutingDailyDetailID
                 inner join TP_PC_GroutingLineDetail on TP_PC_GroutingLineDetail.Groutinglinedetailid =
                                                        Tp_Pm_Inproductiontrash.GroutingLineDetailID
                 inner join TP_MST_Account on TP_MST_Account.Accountid =
                                              Tp_Pm_Inproductiontrash.Accountid
                  left join TP_PM_SCRAPPRODUCT on TP_PM_SCRAPPRODUCT.barcode=Tp_Pm_Inproductiontrash.barcode
                  left join TP_MST_GoodsLevel on TP_MST_GoodsLevel.GoodsLevelID =
                                                 TP_PM_SCRAPPRODUCT.GoodsLevelID
                  left join TP_SYS_GoodsLevelType on TP_SYS_GoodsLevelType.GoodsLevelTypeID =
                                                     TP_PM_SCRAPPRODUCT.GoodsLevelTypeID
                  
                 Where 1 = 1
                   and Tp_Pm_Inproductiontrash.ValueFlag = 1
                   and Tp_Pm_Inproductiontrash.AccountID = :AccountID";

			return selSql;
		}

		#endregion

		#region 清除在产临时表数据


		public static ServiceResultEntity GetPM2112Data(SUserInfo user, FPM2112_SE se)
		{
			IDBConnection conn = null;
			try
			{
				conn = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);

				List<OracleParameter> parameters = new List<OracleParameter>();
				StringBuilder sql = new StringBuilder(PMModuleLogic.GetPM2112SQL());
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, user.AccountID, ParameterDirection.Input));

				if (se != null)
				{
					//生产线IDS
					if (!string.IsNullOrEmpty(se.ProductionLineIDS))
					{
						sql.Append("  AND instr(','||:ProductionLineIDS||',',','||Tp_Pm_Inproduction_Tmp.ProductionLineID||',')>0 ");
						parameters.Add(new OracleParameter(":ProductionLineIDS", OracleDbType.NVarchar2, se.ProductionLineIDS, ParameterDirection.Input));
					}

					//完成工序IDS
					if (!string.IsNullOrEmpty(se.ProcedureIDS))
					{
						sql.Append("  AND instr(','||:ProcedureIDS||',',','||Tp_Pm_Inproduction_Tmp.ProcedureID||',')>0 ");
						parameters.Add(new OracleParameter(":ProcedureIDS", OracleDbType.NVarchar2, se.ProcedureIDS, ParameterDirection.Input));
					}


					// 生产时间--开始
					if (se.UpdateTimeStart.HasValue)
					{
						sql.Append("  AND Tp_Pm_Inproduction_Tmp.Proceduretime >= :UpdateTimeStart ");
						parameters.Add(new OracleParameter(":UpdateTimeStart", OracleDbType.Date, se.UpdateTimeStart.Value, ParameterDirection.Input));
					}

					// 生产时间--结束
					if (se.UpdateTimeEnd.HasValue)
					{
						sql.Append("  AND Tp_Pm_Inproduction_Tmp.Proceduretime <= :UpdateTimeEnd ");
						parameters.Add(new OracleParameter(":UpdateTimeEnd", OracleDbType.Date, se.UpdateTimeEnd.Value, ParameterDirection.Input));
					}

					//产品条码
					if (!string.IsNullOrEmpty(se.Barcode))
					{
						sql.Append("  AND instr(Tp_Pm_Inproduction_Tmp.barcode,:barcode)>0 ");
						parameters.Add(new OracleParameter(":barcode", OracleDbType.NVarchar2, se.Barcode, ParameterDirection.Input));
					}

					if (se.TrashFlag == 1)
					{
						//报废日期开始
						if (se.ScrapDataStart.HasValue)
						{
							sql.Append("  AND TP_PM_SCRAPPRODUCT.SCRAPDATE >= trunc(:ScrapDateStart) ");
							parameters.Add(new OracleParameter(":ScrapDateStart", OracleDbType.Date, se.ScrapDataStart.Value, ParameterDirection.Input));
						}

						//报废日期结束
						if (se.ScrapDataEnd.HasValue)
						{
							sql.Append("  AND TP_PM_SCRAPPRODUCT.SCRAPDATE <= trunc(:ScrapDateEnd)");
							parameters.Add(new OracleParameter(":ScrapDateEnd", OracleDbType.Date, se.ScrapDataEnd.Value, ParameterDirection.Input));
						}
					}


					// 清除时间
					if (se.DeletedTimeStart.HasValue)
					{
						sql.Append("  AND Tp_Pm_Inproduction_Tmp.deletedtime >= :deletedtime ");
						parameters.Add(new OracleParameter(":deletedtime", OracleDbType.Date, se.DeletedTimeStart.Value, ParameterDirection.Input));
					}

					// 清除时间--结束
					if (se.DeletedTimeEnd.HasValue)
					{
						sql.Append("  AND Tp_Pm_Inproduction_Tmp.deletedtime <= :deletedtimeEnd ");
						parameters.Add(new OracleParameter(":deletedtimeEnd", OracleDbType.Date, se.DeletedTimeEnd.Value, ParameterDirection.Input));
					}

					if (se.GooddLevelTypeID != -100)
					{
						// 产品分级
						sql.Append("  AND TP_PM_SCRAPPRODUCT.GOODSLEVELTYPEID = :GooddLevelTypeID ");
						parameters.Add(new OracleParameter(":GooddLevelTypeID", OracleDbType.Int32, se.GooddLevelTypeID, ParameterDirection.Input));
					}
					else
					{
						// 产品分级
						//// sql.Append("  AND TP_PM_SCRAPPRODUCT.GOODSLEVELTYPEID is null ");
					}

					//数据来源
					sql.Append("  AND Tp_Pm_Inproduction_Tmp.TrashFlag = :TrashFlag ");
					parameters.Add(new OracleParameter(":TrashFlag", OracleDbType.Int32, se.TrashFlag, ParameterDirection.Input));

				}
				sql.Append("  order by Tp_Pm_Inproduction_Tmp.UpdateTime desc");
				DataTable data = conn.GetSqlResultToDt(sql.ToString(), parameters.ToArray());

				ServiceResultEntity sre = new ServiceResultEntity();
				if (data == null || data.Rows.Count == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoSearchResults;
					return sre;
				}
				sre.Data = new DataSet();
				sre.Data.Tables.Add(data);
				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (conn != null &&
					conn.ConnState == ConnectionState.Open)
				{
					conn.Close();
				}
			}
		}


		/// <summary>
		/// 获取RPT010401画面（在产品明细表）的查询sql
		/// </summary>
		/// <returns>sql</returns>
		private static string GetPM2112SQL()
		{
			string selSql =
				@"SELECT 0 as Sel,
                       TP_PM_SCRAPPRODUCT.SCRAPDATE,
                       Tp_Pm_Inproduction_Tmp.BarCode,
                       Tp_Pm_Inproduction_Tmp.GoodsID,
                       Tp_Pm_Inproduction_Tmp.GoodsCode,
                       Tp_Pm_Inproduction_Tmp.GoodsName,
                       Tp_Pm_Inproduction_Tmp.Userid,
                       A.USERNAME as UserName,
                       A.USERCode as UserCode,
                       Tp_Pm_Inproduction_Tmp.ProductionLineID,
                       Tp_Pm_Inproduction_Tmp.ProductionLineCode,
                       Tp_Pm_Inproduction_Tmp.ProductionLineName,
                       Tp_Pm_Inproduction_Tmp.ModelType,
                       --decode(Tp_Pm_Inproduction_Tmp.IsPublicBody, '1', '是', '否') as IsPublicBody,
                       --decode(Tp_Pm_Inproduction_Tmp.IsReFire, '1', '是', '否') as IsReFire,
                       Tp_Pm_Inproduction_Tmp.IsPublicBody,
                       Tp_Pm_Inproduction_Tmp.IsReFire,
                       decode(Tp_Pm_Inproduction_Tmp.CanManyTimes, '1', '能', '不能') as CanManyTimes,
                       decode(Tp_Pm_Inproduction_Tmp.ProcedureModel,
                              '1',
                              '计件模型',
                              '检验模型') as ProcedureModel,
                       Tp_Pm_Inproduction_Tmp.GroutingDailyID,
                       Tp_Pm_Inproduction_Tmp.GroutingDailyDetailID,
                       Tp_Pm_Inproduction_Tmp.GroutingDate,
                       Tp_Pm_Inproduction_Tmp.GroutingLineID,
                       Tp_Pm_Inproduction_Tmp.GroutingLineCode,
                       Tp_Pm_Inproduction_Tmp.GroutingLineName,
                       Tp_Pm_Inproduction_Tmp.ProcedureID CompleteProcedureID,
                       D.ProcedureName as CompleteProcedureName,
                       Tp_Pm_Inproduction_Tmp.GMouldTypeID,
                       TP_MST_GMouldType.GMOULDTYPENAME as GMouldTypeName,
                       Tp_Pm_Inproduction_Tmp.GroutingLineDetailID,
                       Tp_Pm_Inproduction_Tmp.GroutingMouldCode,
                       Tp_Pm_Inproduction_Tmp.SPECIALREPAIRFLAG,
                       Tp_Pm_Inproduction_Tmp.GROUTINGUSERCODE,
                       TP_PM_GroutingDailyDetail.GROUTINGCOUNT,
                       Tp_Pm_Inproduction_Tmp.Remarks,
                       Tp_Pm_Inproduction_Tmp.GoodsLevelID,
                       TP_MST_GoodsLevel.GOODSLEVELNAME,
                       Tp_Pm_Inproduction_Tmp.GoodsLevelTypeID,
                       TP_SYS_GoodsLevelType.GOODSLEVELTYPENAME,
                       Tp_Pm_Inproduction_Tmp.AccountID,
                       Tp_Pm_Inproduction_Tmp.ValueFlag,
                       Tp_Pm_Inproduction_Tmp.CreateTime,
                       Tp_Pm_Inproduction_Tmp.CreateUserID,
                       B.USERNAME as CreateUserName,
                       Tp_Pm_Inproduction_Tmp.PROCEDURETIME AS UpdateTime,
                       Tp_Pm_Inproduction_Tmp.UpdateUserID,
                       C.USERNAME as UpdateUserName
                  FROM Tp_Pm_Inproduction_Tmp
                 inner join TP_MST_User A on A.UserID = Tp_Pm_Inproduction_Tmp.Userid
                 inner join TP_MST_User B on B.UserID = Tp_Pm_Inproduction_Tmp.CreateUserID
                 inner join TP_MST_User C on C.UserID = Tp_Pm_Inproduction_Tmp.UpdateUserID
                 inner join TP_PC_Procedure D on D.PROCEDUREID =
                                                 Tp_Pm_Inproduction_Tmp.ProcedureID
                 inner join TP_MST_GMouldType on TP_MST_GMouldType.GMouldTypeID =
                                                 Tp_Pm_Inproduction_Tmp.GMouldTypeID
                 inner join TP_PM_GroutingDaily on TP_PM_GroutingDaily.GroutingDailyID =
                                                   Tp_Pm_Inproduction_Tmp.GroutingDailyID
                 inner join TP_PM_GroutingDailyDetail on TP_PM_GroutingDailyDetail.Groutingdailydetailid =
                                                         Tp_Pm_Inproduction_Tmp.GroutingDailyDetailID
                 inner join TP_PC_GroutingLineDetail on TP_PC_GroutingLineDetail.Groutinglinedetailid =
                                                        Tp_Pm_Inproduction_Tmp.GroutingLineDetailID
                 inner join TP_MST_Account on TP_MST_Account.Accountid =
                                              Tp_Pm_Inproduction_Tmp.Accountid
                  left join TP_MST_GoodsLevel on TP_MST_GoodsLevel.GoodsLevelID =
                                                 Tp_Pm_Inproduction_Tmp.GoodsLevelID
                  left join TP_SYS_GoodsLevelType on TP_SYS_GoodsLevelType.GoodsLevelTypeID =
                                                     Tp_Pm_Inproduction_Tmp.GoodsLevelTypeID
                  left join TP_PM_SCRAPPRODUCT on TP_PM_SCRAPPRODUCT.barcode=Tp_Pm_Inproduction_Tmp.barcode and TP_PM_SCRAPPRODUCT.AUDITSTATUS=1 and TP_PM_SCRAPPRODUCT.RECYCLINGFLAG='0' and TP_PM_SCRAPPRODUCT.GOODSLEVELTYPEID=8
                 Where Tp_Pm_Inproduction_Tmp.AccountID = :AccountID";

			return selSql; //and Tp_Pm_Inproduction_Tmp.ValueFlag = 1
		}

		#endregion

		/// <summary>
		/// 工序是否有商标ID
		/// <param name="ProcedureID">工序ID</param>
		/// </summary>
		/// <returns>int</returns>
		public static int GetLogoID(int ProcedureID, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select LogoID from tp_pc_procedure where accountid=:accountid and ProcedureID=:ProcedureID";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":accountid",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
					new OracleParameter(":ProcedureID",OracleDbType.Int32, ProcedureID,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					if (ds.Tables[0].Rows[0]["LogoID"] == DBNull.Value)
					{
						return 0;
					}
					else
					{
						return Convert.ToInt32(ds.Tables[0].Rows[0]["LogoID"]);
					}
				}
				return 0;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取条码商标
		/// <param name="barcode">产品条码</param>
		/// </summary>
		/// <returns>int</returns>
		public static DataSet GetBarCodeLogoID(string barcode, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();

				// 转换条码
				string sqlString = @"select FUN_CMN_GetBarCode(:barcode,null,:accountid) From DUAL";
				OracleParameter[] paras1 = new OracleParameter[]{
									new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
									new OracleParameter(":accountid",OracleDbType.Int32, sUserInfo.AccountID,ParameterDirection.Input),
								};
				barcode = con.GetSqlResultToStr(sqlString, paras1);

				sqlString = @"select g.LogoID,l.logocode,l.logoname, g.glazetypeid, d.DICTIONARYVALUE glazetypename, g.goodsid, f.fhuserid, '' err_msg
                                from tp_pm_groutingdailydetail g
                                     left join tp_mst_logo l on g.logoid=l.logoid
                                     left join TP_MST_DataDictionary d on d.DICTIONARYID = g.glazetypeid
                                     left join tp_pm_finishedproduct f on g.barcode = f.barcode
                                        where g.barcode=:barcode";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					object fhuserid = ds.Tables[0].Rows[0]["fhuserid"];
					if (fhuserid != null && fhuserid != DBNull.Value)
					{
						ds.Tables[0].Rows[0]["err_msg"] = "已交接的产品不能变更商标";
					}
					return ds;
				}
				return null;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 半检时,入窑前检验获取此条码是否报损为废品
		/// <param name="barcode">产品条码</param>
		/// </summary>
		/// <returns>int</returns>
		public static int CheckWasteScrapProduct(string barcode)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select auditstatus from tp_pm_scrapproduct where auditstatus in(0,1) and valueflag=1 and goodsleveltypeid=3 and barcode=:barcode";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":barcode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					return Convert.ToInt32(ds.Tables[0].Rows[0]["auditstatus"]);
				}
				return -100;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取盘点单明细
		/// </summary>
		/// <param name="procedureID">工序ID</param>
		/// <returns>DataSet</returns>
		public static DataSet GetUpdateInCheckedInfo(string incheckedno, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select tp_pm_inchecked.incheckedid from tp_pm_inchecked where tp_pm_inchecked.incheckedno=:incheckedno";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":incheckedno",OracleDbType.Varchar2, incheckedno,ParameterDirection.Input),
				};
				DataSet dsReturn = null;
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					int incheckedid = Convert.ToInt32(ds.Tables[0].Rows[0]["incheckedid"]);
					sqlString = @"SELECT to_char(checked.UserCheckedCount) || '/' ||
                                   to_char(checked.CheckedCount) CheckedCount
                                  ,to_char(checked.UserOverageCount) || '/' ||
                                   to_char(checked.OverageCount) OverageCount
                                  ,to_char(checked.UserCheckedCount + checked.UserOverageCount) || '/' ||
                                   to_char(checked.CheckedCount + checked.OverageCount) || '/' ||
                                   to_char(TCount) TCount
                              FROM (SELECT icd.incheckedid
                                          , SUM(CASE
                                                  WHEN icd.checkeduserid = :userid AND icd.InCheckedFlag = '1' THEN
                                                   1
                                                  ELSE
                                                   0
                                                END) UserCheckedCount
                                          , SUM(CASE
                                                  WHEN icd.checkeduserid = :userid AND icd.InCheckedFlag = '2' THEN
                                                   1
                                                  ELSE
                                                   0
                                                END) UserOverageCount
                                          , SUM(CASE
                                                  WHEN icd.InCheckedFlag = '1' THEN
                                                   1
                                                  ELSE
                                                   0
                                                END) CheckedCount
                                          , SUM(CASE
                                                  WHEN icd.InCheckedFlag = '2' THEN
                                                   1
                                                  ELSE
                                                   0
                                                END) OverageCount
                                          ,COUNT(icd.incheckedid) TCount
                                      FROM tp_pm_incheckeddetail icd
                                     WHERE icd.incheckedid = :incheckedid
                                       AND icd.valueflag = '1'
                                     GROUP BY icd.incheckedid) checked";
					paras = new OracleParameter[]{
					new OracleParameter(":incheckedid",OracleDbType.Int32, incheckedid,ParameterDirection.Input),
					new OracleParameter(":userid",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
						  };
					ds = con.GetSqlResultToDs(sqlString, paras);
					ds.Tables[0].TableName = "Table1";
					dsReturn = new DataSet();
					dsReturn.Tables.Add(ds.Tables[0].Copy());

					sqlString = @"
                                SELECT icd.goodscode, COUNT(icd.goodscode) goodscount
                                  FROM tp_pm_incheckeddetail icd
                                 WHERE icd.incheckedid = :incheckedid
                                   AND icd.checkeduserid = :userid
                                   AND icd.InCheckedFlag = '1'
                                   AND icd.valueflag = '1'
                                 GROUP BY icd.goodscode";
					paras = new OracleParameter[]{
					new OracleParameter(":incheckedid",OracleDbType.Int32, incheckedid,ParameterDirection.Input),
					new OracleParameter(":userid",OracleDbType.Int32, sUserInfo.UserID,ParameterDirection.Input),
						  };
					ds = con.GetSqlResultToDs(sqlString, paras);
					ds.Tables[0].TableName = "Table2";
					dsReturn.Tables.Add(ds.Tables[0].Copy());

				}
				return dsReturn;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取半成品检验列表
		/// <param name="entity">实体类</param>
		/// </summary>
		/// <returns>DataSet</returns>
		public static DataSet GetSemiCheck(SemiCheckEntity entity, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				List<OracleParameter> parameters = new List<OracleParameter>();
				parameters.Add(new OracleParameter(":AccountID", OracleDbType.Int32, sUserInfo.AccountID, ParameterDirection.Input));
				string sqlString = @"select 
                                    SemiCheck.SemiCheckID,
                                    CProcedure.ProcedureName as CProcedureName,
                                    SemiCheck.ProcedureTime,
                                    SemiCheck.UserCode,
                                    GoodsType2.GoodsTypeName as LevelGoodsTypeName,
                                    GoodsType.GoodsTypeName,
                                    Goods.GoodsCode,
                                    SemiCheck.BarCode,
                                    -- 复检后不显示半检状态
                                    SemiCheckType.SemiCheckTypeName,
                                    --decode(SemiCheck.ReSemiCheckType, 0, SemiCheckType.SemiCheckTypeName, '已复检') SemiCheckTypeName
                                    SemiCheck.SemiCheckUserCode,
                                    SemiCheck.SemiCheckTime,
                                    ReSemiCheckType.ReSemiCheckTypeName,
                                    SemiCheck.ReSemiCheckUserCode,
                                    SemiCheck.ReSemiCheckTime,
                                    decode(SemiCheck.BackOutFlag,'0','正常','撤销') as BackOutFlag,
                                    SemiCheck.BackOutUserCode,
                                    SemiCheck.BackOutTime,
                                    SemiCheck.GroutingUserCode,
                                    SemiCheck.GroutingDate,
                                    GroutingDailyDetail.DeliverTime,
                                    logo.logoName,
                                    RProcedure.ProcedureName as RProcedureName,
                                    SemiCheck.ReworkUserCode
                                    from  TP_PM_SemiCheck SemiCheck
                                    left join TP_PC_Procedure CProcedure
                                    on SemiCheck.ProcedureID=CProcedure.ProcedureID
                                    left join TP_MST_Goods Goods
                                    on SemiCheck.GoodsID=Goods.GoodsID
                                    left join TP_MST_GoodsType GoodsType
                                    on Goods.GoodsTypeID=GoodsType.GoodsTypeID
                                    left join TP_MST_GoodsType GoodsType2
                                    on GoodsType2.accountid=GoodsType.accountid
                                    and GoodsType2.GoodsTypecode=substr(GoodsType.GoodsTypecode,1,6)
                                    left join TP_SYS_SemiCheckType SemiCheckType
                                    on SemiCheck.SemiCheckType=SemiCheckType.SemiCheckTypeID
                                    left join TP_SYS_ReSemiCheckType ReSemiCheckType
                                    on SemiCheck.ReSemiCheckType=ReSemiCheckType.ReSemiCheckTypeID
                                    left join TP_PM_GroutingDailyDetail GroutingDailyDetail
                                    on GroutingDailyDetail.GroutingDailyDetailID=SemiCheck.GroutingDailyDetailID
                                    left join TP_MST_Logo logo
                                    on GroutingDailyDetail.LogoID=logo.LogoID
                                    left join TP_PC_Procedure RProcedure
                                    on SemiCheck.ReworkProcedureID=RProcedure.ProcedureID
                                    where SemiCheck.AccountID=:AccountID
                                    ";
				// 完成工序
				if (!string.IsNullOrEmpty(entity.CProcedureIDS))
				{
					sqlString = sqlString + " AND instr(','||:CProcedureIDS||',',','||SemiCheck.ProcedureID||',')>0 ";
					parameters.Add(new OracleParameter(":CProcedureIDS", OracleDbType.NVarchar2, entity.CProcedureIDS, ParameterDirection.Input));
				}
				// 完成时间起始
				if (entity.CDateTimeStart.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.ProcedureTime >= :CDateTimeStart ";
					parameters.Add(new OracleParameter(":CDateTimeStart", OracleDbType.Date, entity.CDateTimeStart.Value, ParameterDirection.Input));
				}
				// 完成时间结束
				if (entity.CDateTimeEnd.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.ProcedureTime <= :CDateTimeEnd ";
					parameters.Add(new OracleParameter(":CDateTimeEnd", OracleDbType.Date, entity.CDateTimeStart.Value, ParameterDirection.Input));
				}
				// 完成工号
				if (!string.IsNullOrEmpty(entity.CUserCode))
				{
					sqlString = sqlString + "  AND instr(SemiCheck.UserCode,:UserCode)>0";
					parameters.Add(new OracleParameter(":UserCode", OracleDbType.NVarchar2, entity.CUserCode, ParameterDirection.Input));
				}
				// 产品类别
				if (!string.IsNullOrEmpty(entity.GoodsTypeCode))
				{
					sqlString = sqlString + " AND instr(GoodsType.GoodsTypeCode,:GoodsTypeCode)=1 ";
					parameters.Add(new OracleParameter(":GoodsTypeCode", OracleDbType.NVarchar2, entity.GoodsTypeCode, ParameterDirection.Input));
				}
				// 产品编码
				if (!string.IsNullOrEmpty(entity.GoodsCode))
				{
					sqlString = sqlString + "  AND instr(Goods.GoodsCode,:GoodsCode)>0";
					parameters.Add(new OracleParameter(":GoodsCode", OracleDbType.NVarchar2, entity.GoodsCode, ParameterDirection.Input));
				}
				// 成型工号
				if (!string.IsNullOrEmpty(entity.GroutingUserCode))
				{
					sqlString = sqlString + "  AND instr(SemiCheck.GroutingUserCode,:GroutingUserCode)>0";
					parameters.Add(new OracleParameter(":GroutingUserCode", OracleDbType.NVarchar2, entity.GroutingUserCode, ParameterDirection.Input));
				}
				// 注浆时间起始
				if (entity.GroutingDateTimeStart.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.GroutingDate >= :GroutingDateTimeStart ";
					parameters.Add(new OracleParameter(":GroutingDateTimeStart", OracleDbType.Date, entity.GroutingDateTimeStart.Value, ParameterDirection.Input));
				}
				// 注浆时间结束
				if (entity.GroutingDateTimeEnd.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.GroutingDate <= :GroutingDateTimeEnd ";
					parameters.Add(new OracleParameter(":GroutingDateTimeEnd", OracleDbType.Date, entity.GroutingDateTimeEnd.Value, ParameterDirection.Input));
				}
				// 交坯时间起始
				if (entity.DeliveryDateTimeStart.HasValue)
				{
					sqlString = sqlString + " AND GroutingDailyDetail.DeliverTime >= :DeliveryDateTimeStart ";
					parameters.Add(new OracleParameter(":DeliveryDateTimeStart", OracleDbType.Date, entity.DeliveryDateTimeStart.Value, ParameterDirection.Input));
				}
				// 交坯时间结束
				if (entity.DeliveryDateTimeEnd.HasValue)
				{
					sqlString = sqlString + " AND GroutingDailyDetail.DeliverTime <= :DeliveryDateTimeEnd ";
					parameters.Add(new OracleParameter(":DeliveryDateTimeEnd", OracleDbType.Date, entity.DeliveryDateTimeEnd.Value, ParameterDirection.Input));
				}
				// 半检状态
				if (!string.IsNullOrEmpty(entity.SemiCheckType))
				{
					sqlString = sqlString + " AND instr(','||:SemiCheckType||',',','||SemiCheck.SemiCheckType||',')>0 ";
					parameters.Add(new OracleParameter(":SemiCheckType", OracleDbType.NVarchar2, entity.SemiCheckType, ParameterDirection.Input));
				}
				// 半检时间起始
				if (entity.SemiCheckDateTimeStart.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.SemiCheckTime >= :SemiCheckDateTimeStart ";
					parameters.Add(new OracleParameter(":SemiCheckDateTimeStart", OracleDbType.Date, entity.SemiCheckDateTimeStart.Value, ParameterDirection.Input));
				}
				// 半检时间结束
				if (entity.SemiCheckDateTimeEnd.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.SemiCheckTime <= :SemiCheckDateTimeEnd ";
					parameters.Add(new OracleParameter(":SemiCheckDateTimeEnd", OracleDbType.Date, entity.SemiCheckDateTimeEnd.Value, ParameterDirection.Input));
				}
				// 半检工号
				if (!string.IsNullOrEmpty(entity.SemiCheckUserCode))
				{
					sqlString = sqlString + "  AND instr(SemiCheck.SemiCheckUserCode,:SemiCheckUserCode)>0";
					parameters.Add(new OracleParameter(":SemiCheckUserCode", OracleDbType.NVarchar2, entity.SemiCheckUserCode, ParameterDirection.Input));
				}
				// 返工工序
				if (!string.IsNullOrEmpty(entity.RProcedureIDS))
				{
					sqlString = sqlString + " AND instr(','||:RProcedureIDS||',',','||SemiCheck.ReworkProcedureID||',')>0 ";
					parameters.Add(new OracleParameter(":RProcedureIDS", OracleDbType.NVarchar2, entity.RProcedureIDS, ParameterDirection.Input));
				}
				// 返工工号
				if (!string.IsNullOrEmpty(entity.ReworkUserCode))
				{
					sqlString = sqlString + "  AND instr(SemiCheck.ReworkUserCode,:ReworkUserCode)>0";
					parameters.Add(new OracleParameter(":ReworkUserCode", OracleDbType.NVarchar2, entity.ReworkUserCode, ParameterDirection.Input));
				}
				// 复检状态
				if (!string.IsNullOrEmpty(entity.ReSemiCheckType))
				{
					sqlString = sqlString + " AND instr(','||:ReSemiCheckType||',',','||SemiCheck.ReSemiCheckType||',')>0 ";
					parameters.Add(new OracleParameter(":ReSemiCheckType", OracleDbType.NVarchar2, entity.ReSemiCheckType, ParameterDirection.Input));
				}
				// 复检时间起始
				if (entity.ReSemiCheckDateTimeStart.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.ReSemiCheckTime >= :ReSemiCheckDateTimeStart ";
					parameters.Add(new OracleParameter(":ReSemiCheckDateTimeStart", OracleDbType.Date, entity.ReSemiCheckDateTimeStart.Value, ParameterDirection.Input));
				}
				// 复检时间结束
				if (entity.ReSemiCheckDateTimeEnd.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.ReSemiCheckTime <= :ReSemiCheckDateTimeEnd ";
					parameters.Add(new OracleParameter(":ReSemiCheckDateTimeEnd", OracleDbType.Date, entity.ReSemiCheckDateTimeEnd.Value, ParameterDirection.Input));
				}
				// 复检工号
				if (!string.IsNullOrEmpty(entity.ReSemiCheckUserCode))
				{
					sqlString = sqlString + "  AND instr(SemiCheck.ReSemiCheckUserCode,:ReSemiCheckUserCode)>0";
					parameters.Add(new OracleParameter(":ReSemiCheckUserCode", OracleDbType.NVarchar2, entity.ReSemiCheckUserCode, ParameterDirection.Input));
				}
				// 撤销标识
				if (!string.IsNullOrEmpty(entity.BackOutFlag))
				{
					sqlString = sqlString + " AND instr(','||:BackOutFlag||',',','||SemiCheck.BackOutFlag||',')>0 ";
					parameters.Add(new OracleParameter(":BackOutFlag", OracleDbType.NVarchar2, entity.BackOutFlag, ParameterDirection.Input));
				}
				// 撤销时间起始
				if (entity.BackOutTimeStart.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.BackOutTime >= :BackOutTimeStart ";
					parameters.Add(new OracleParameter(":BackOutTimeStart", OracleDbType.Date, entity.BackOutTimeStart.Value, ParameterDirection.Input));
				}
				// 撤销时间结束
				if (entity.BackOutTimeEnd.HasValue)
				{
					sqlString = sqlString + " AND SemiCheck.BackOutTime <= :BackOutTimeEnd ";
					parameters.Add(new OracleParameter(":BackOutTimeEnd", OracleDbType.Date, entity.BackOutTimeEnd.Value, ParameterDirection.Input));
				}
				// 撤销工号
				if (!string.IsNullOrEmpty(entity.BackOutUserCode))
				{
					sqlString = sqlString + "  AND instr(SemiCheck.BackOutUserCode,:BackOutUserCode)>0";
					parameters.Add(new OracleParameter(":BackOutUserCode", OracleDbType.NVarchar2, entity.BackOutUserCode, ParameterDirection.Input));
				}
				// 产品条码
				if (!string.IsNullOrEmpty(entity.BarCode))
				{
					sqlString = sqlString + "  AND instr(SemiCheck.BarCode,:BarCode)>0";
					parameters.Add(new OracleParameter(":BarCode", OracleDbType.NVarchar2, entity.BarCode, ParameterDirection.Input));
				}
				DataSet ds = con.GetSqlResultToDs(sqlString, parameters.ToArray());
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					return ds;
				}
				return null;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取半成品检验缺陷列表
		/// <param name="semiCheckID">半成品检验ID</param>
		/// </summary>
		/// <returns>DataSet</returns>
		public static DataSet GetSemiCheckDefect(int semiCheckID)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				List<OracleParameter> parameters = new List<OracleParameter>();
				parameters.Add(new OracleParameter(":semiCheckID", OracleDbType.Int32, semiCheckID, ParameterDirection.Input));
				string sqlString = @"select 
                                    TP_PM_SemiCheckDefect.DefectCode,
                                    TP_PM_SemiCheckDefect.DefectName,
                                    TP_PM_SemiCheckDefect.DefectPositionCode,
                                    TP_PM_SemiCheckDefect.DefectPositionName,
                                    TP_PC_Procedure.ProcedureName,
                                    TP_PM_SemiCheckDefect.DefectUserCode
                                    from  TP_PM_SemiCheckDefect 
                                    left join TP_PC_Procedure
                                    on TP_PM_SemiCheckDefect.DefectProcedureID=TP_PC_Procedure.ProcedureID
                                    where TP_PM_SemiCheckDefect.semiCheckID=:semiCheckID
                                    ";
				DataSet ds = con.GetSqlResultToDs(sqlString, parameters.ToArray());
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					return ds;
				}
				return null;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}


		/// <summary>
		/// 根据所选工号，查出缺陷责任员工
		/// </summary>
		/// <param name="userid">用户ID</param>
		/// <param name="sUserInfo">用户基本信息</param>
		/// <returns>DataSet</returns>
		public static DataSet GetSemiCheckDefectStaffByUserID(SUserInfo sUserInfo, int userid)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = @"select 
                             TP_HR_Staff.StaffID,TP_HR_Staff.StaffCode,TP_HR_Staff.StaffName,
                            TP_HR_Staff.StaffStatus,TP_MST_UserStaff.UJobsID as SJobsID,
                            TP_MST_UserStaff.Ujobsid
                            from  TP_MST_UserStaff
                            left join TP_HR_Staff
                            on TP_MST_UserStaff.Staffid=TP_HR_Staff.Staffid
                            where  TP_MST_UserStaff.Userid=:userid
                                    ";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":userid",OracleDbType.Int32, userid,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				return ds;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 获取标识
		/// </summary>
		/// <param name="barcode">产品条码</param>ram>
		/// <returns>int</returns>
		public static int GetRecyclingflagByBarcode(string barcode, SUserInfo sUserInfo)
		{
			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				string sqlString = "select recyclingflag from TP_PM_ScrapProduct "
						  + " where BarCode=:BarCode and CreateTime=(select max(CreateTime) "
						  + " from TP_PM_ScrapProduct "
						  + " where BarCode=:BarCode and ValueFlag=1)"
						  + "  and ValueFlag=1";
				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":BarCode",OracleDbType.Varchar2, barcode,ParameterDirection.Input),
				};
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				if (ds != null && ds.Tables[0].Rows.Count > 0)
				{
					return Convert.ToInt32(ds.Tables[0].Rows[0]["recyclingflag"]);
				}
				return 0;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		#region 点位库存
		/// <summary>
		/// 查询点位库存
		/// </summary>
		/// <param name="barcode">产品条码</param>ram>
		/// <returns>int</returns>
		public static ServiceResultEntity GetWareHouseCall(ClientRequestEntity cre, SUserInfo sUserInfo)
		{

			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				ServiceResultEntity sre = new ServiceResultEntity();

				#region 执行SQL
				string sqlString =
				@"SELECT
	                        WAREHOUSETYPE,
	                        WAREHOUSEROOM,
	                        WAREHOUSECALL 
                        FROM
	                        TP_PC_WAREHOUSECALL W 
                        WHERE 1=1";
				if (cre.Properties["WareHouseTypeID"].ToString() != "")
				{
					sqlString += " AND W.WAREHOUSETYPE = :WAREHOUSETYPE ";
				}
				if (cre.Properties["WareHouseTypeRoom"].ToString() != "")
				{
					sqlString += " AND W.WAREHOUSEROOM = :WAREHOUSEROOM ";
				}
				sqlString +=
					@" AND W.WAREHOUSECALL LIKE :WAREHOUSECALL 
						  ORDER BY WAREHOUSETYPE, WAREHOUSEROOM, WAREHOUSECALL";

				OracleParameter[] paras = new OracleParameter[]{
					new OracleParameter(":WAREHOUSETYPE",OracleDbType.Varchar2, cre.Properties["WareHouseTypeID"],ParameterDirection.Input),
					new OracleParameter(":WAREHOUSEROOM",OracleDbType.Varchar2, cre.Properties["WareHouseTypeRoom"],ParameterDirection.Input),
					new OracleParameter(":WAREHOUSECALL",OracleDbType.Varchar2,"%"+ cre.Properties["WareHouseCall"]+"%",ParameterDirection.Input)
				};
				#endregion

				#region 结果赋值
				DataSet ds = con.GetSqlResultToDs(sqlString, paras);
				sre.Data = ds;
				#endregion

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}

		/// <summary>
		/// 新增点位库存
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns></returns>
		public static ServiceResultEntity AddWareHouseCall(ClientRequestEntity cre, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				ServiceResultEntity sre = new ServiceResultEntity();
				#region 数据重复检验
				#region 执行查询SQL
				string sqlSel =
					@"SELECT
	                        WAREHOUSETYPE,
	                        WAREHOUSEROOM,
	                        WAREHOUSECALL 
                        FROM
	                        TP_PC_WAREHOUSECALL W 
                        WHERE 1=1";
				if (cre.Properties["WareHouseTypeID"].ToString() != "")
				{
					sqlSel += " AND W.WAREHOUSETYPE = :WAREHOUSETYPE ";
				}
				if (cre.Properties["WareHouseTypeRoom"].ToString() != "")
				{
					sqlSel += " AND W.WAREHOUSEROOM = :WAREHOUSEROOM ";
				}
				sqlSel +=
					@" AND W.WAREHOUSECALL = :WAREHOUSECALL 
						  ORDER BY WAREHOUSETYPE, WAREHOUSEROOM, WAREHOUSECALL";

				OracleParameter[] parasSel = new OracleParameter[]{
					new OracleParameter(":WAREHOUSETYPE",OracleDbType.Varchar2, cre.Properties["WareHouseTypeID"], ParameterDirection.Input),
					new OracleParameter(":WAREHOUSEROOM",OracleDbType.Varchar2, cre.Properties["WareHouseTypeRoom"], ParameterDirection.Input),
					new OracleParameter(":WAREHOUSECALL",OracleDbType.Varchar2, cre.Properties["WareHouseCall"], ParameterDirection.Input)
				};
				#endregion

				#region 查询校验
				DataTable dt = oracleTrConn.GetSqlResultToDt(sqlSel, parasSel);
				if (dt != null && dt.Rows.Count > 0)
				{
					sre.Status = Constant.ServiceResultStatus.DataDuplicated;
					oracleTrConn.Disconnect();
					return sre;
				}
				#endregion
				#endregion

				#region 执行新增SQL
				string sqlIns =
					@"INSERT INTO TP_PC_WAREHOUSECALL 
						( WAREHOUSETYPE, 
						WAREHOUSEROOM, 
						WAREHOUSECALL )
						VALUES 
						(:WAREHOUSETYPE, 
						:WAREHOUSEROOM, 
						:WAREHOUSECALL)";

				OracleParameter[] parasIns = new OracleParameter[]{
					new OracleParameter(":WAREHOUSETYPE", OracleDbType.Varchar2, cre.Properties["WareHouseTypeID"], ParameterDirection.Input),
					new OracleParameter(":WAREHOUSEROOM", OracleDbType.Varchar2, cre.Properties["WareHouseTypeRoom"], ParameterDirection.Input),
					new OracleParameter(":WAREHOUSECALL", OracleDbType.Varchar2, cre.Properties["WareHouseCall"], ParameterDirection.Input)
				};

				int result = oracleTrConn.ExecuteNonQuery(sqlIns, parasIns);
				#endregion

				#region 执行结果处理
				if (result > 0)
				{
					sre.Status = Constant.ServiceResultStatus.Success;
					oracleTrConn.Commit();
					oracleTrConn.Disconnect();
				}
				else
				{
					sre.Status = Constant.ServiceResultStatus.SystemError;
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				#endregion

				return sre;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}

		/// <summary>
		/// 编辑点位库存
		/// </summary>
		/// <param name="barcode">产品条码</param>
		/// <returns></returns>
		public static ServiceResultEntity EditWareHouseCall(ClientRequestEntity cre, SUserInfo sUserInfo)
		{
			IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				oracleTrConn.Connect();
				ServiceResultEntity sre = new ServiceResultEntity();
				#region 数据重复检验
				#region 执行查询SQL
				string sqlSel =
					@"SELECT
	                        WAREHOUSETYPE,
	                        WAREHOUSEROOM,
	                        WAREHOUSECALL 
                        FROM
	                        TP_PC_WAREHOUSECALL W 
                        WHERE 1=1";
				if (cre.Properties["WareHouseTypeID"].ToString() != "")
				{
					sqlSel += " AND W.WAREHOUSETYPE = :WAREHOUSETYPE ";
				}
				if (cre.Properties["WareHouseTypeRoom"].ToString() != "")
				{
					sqlSel += " AND W.WAREHOUSEROOM = :WAREHOUSEROOM ";
				}
				sqlSel +=
					@" AND W.WAREHOUSECALL = :WAREHOUSECALL 
						  ORDER BY WAREHOUSETYPE, WAREHOUSEROOM, WAREHOUSECALL";

				OracleParameter[] parasSel = new OracleParameter[]{
					new OracleParameter(":WAREHOUSETYPE",OracleDbType.Varchar2, cre.Properties["WareHouseTypeID"], ParameterDirection.Input),
					new OracleParameter(":WAREHOUSEROOM",OracleDbType.Varchar2, cre.Properties["WareHouseTypeRoom"], ParameterDirection.Input),
					new OracleParameter(":WAREHOUSECALL",OracleDbType.Varchar2, cre.Properties["WareHouseCall"], ParameterDirection.Input)
				};
				#endregion

				#region 查询校验
				DataTable dt = oracleTrConn.GetSqlResultToDt(sqlSel, parasSel);
				if (dt != null && dt.Rows.Count > 0)
				{
					sre.Status = Constant.ServiceResultStatus.DataDuplicated;
					oracleTrConn.Disconnect();
					return sre;
				}
				#endregion
				#endregion

				#region 执行新增SQL
				string sqlIns =
					@"UPDATE TP_PC_WAREHOUSECALL 
						SET 
							WAREHOUSETYPE = :WAREHOUSETYPE,
							WAREHOUSEROOM = :WAREHOUSEROOM,
							WAREHOUSECALL = :WAREHOUSECALL 
						WHERE
							WAREHOUSETYPE = :OLDWAREHOUSETYPE
						AND WAREHOUSEROOM = :OLDWAREHOUSEROOM
						AND	WAREHOUSECALL = :OLDWAREHOUSECALL";

				OracleParameter[] parasIns = new OracleParameter[]{
					new OracleParameter(":WAREHOUSETYPE", OracleDbType.Varchar2, cre.Properties["WareHouseTypeID"], ParameterDirection.Input),
					new OracleParameter(":WAREHOUSEROOM", OracleDbType.Varchar2, cre.Properties["WareHouseTypeRoom"], ParameterDirection.Input),
					new OracleParameter(":WAREHOUSECALL", OracleDbType.Varchar2, cre.Properties["WareHouseCall"], ParameterDirection.Input),
					new OracleParameter(":OLDWAREHOUSETYPE", OracleDbType.Varchar2, cre.Properties["OLDWareHouseTypeID"], ParameterDirection.Input),
					new OracleParameter(":OLDWAREHOUSEROOM", OracleDbType.Varchar2, cre.Properties["OLDWareHouseTypeRoom"], ParameterDirection.Input),
					new OracleParameter(":OLDWAREHOUSECALL", OracleDbType.Varchar2, cre.Properties["OLDWareHouseCall"], ParameterDirection.Input)
				};

				int result = oracleTrConn.ExecuteNonQuery(sqlIns, parasIns);
				#endregion

				#region 执行结果处理
				if (result > 0)
				{
					sre.Status = Constant.ServiceResultStatus.Success;
					oracleTrConn.Commit();
					oracleTrConn.Disconnect();
				}
				else if (result == 0)
				{
					sre.Status = Constant.ServiceResultStatus.NoModifyData;
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				else
				{
					sre.Status = Constant.ServiceResultStatus.SystemError;
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				#endregion

				return sre;
			}
			catch (Exception ex)
			{
				if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
				{
					oracleTrConn.Rollback();
					oracleTrConn.Disconnect();
				}
				throw ex;
			}
			finally
			{
				if (oracleTrConn.ConnState == ConnectionState.Open)
				{
					oracleTrConn.Disconnect();
				}
			}
		}
		#endregion

		#region 查询注浆确定表
		public static ServiceResultEntity GetAllGROUTINGCHECK(ClientRequestEntity cre, SUserInfo sUserInfo)
		{

			IDBConnection con = ClsDbFactory.CreateDBConnection(DataBaseType.ORACLE, DataManager.ConnectionString);
			try
			{
				con.Open();
				ServiceResultEntity sre = new ServiceResultEntity();
				string startdata = cre.Properties["startdata"] == null ? "" : " AND f.GROUTINGDATE >= TO_DATE ('" + cre.Properties["startdata"].ToString() + "','YYYY/MM/DD') ";
				string enddata = cre.Properties["enddata"] == null ? "" : " AND f.GROUTINGDATE <=TO_DATE ('" + cre.Properties["enddata"].ToString() + "','YYYY/MM/DD') ";
				string usercode = cre.Properties["usercode"].ToString() == ""    ? "" : "AND f.USERCODE='" + cre.Properties["usercode"].ToString().Trim() + "'";

				#region 结果赋值
				DataSet ds = con.GetSqlResultToDs(" SELECT"+
													" f.BARCODE,"+ 
													" f.GOODSCODE,"+
													" f.GROUTINGDATE,"+
													" f.USERCODE," +
													" f.GROUTINGMOULDCODE "+
													" FROM "+
													" tp_pm_groutingdailydetail f "+
													" INNER JOIN TP_PM_GROUTINGCHECK t ON t.GROUTINGDAILYDETAILID = f.GROUTINGDAILYDETAILID "+
													" WHERE 1 = 1 "+ startdata+ enddata+ usercode);
				sre.Data = ds;
				#endregion

				return sre;
			}
			catch (Exception ex)
			{
				throw ex;
			}
			finally
			{
				if (con.ConnState == ConnectionState.Open)
				{
					con.Close();
				}
			}
		}
		#endregion

	}
}