/***文档注释***********************************************
 * 作者               :                   易鑫
 * 创建日期      :                   2016.01.17
 * 描述               :                   下拉列表数据访问类
 * 注意事项      :                   无
 * 遗留BUG :                   无
 * 修改日期      :                   2016.04.12
 * 修改人员      :                   易鑫
 * 修改内容      :                   增加App端调用方法
 ***********************************************************/

package market.Com.impl;

import java.sql.Connection;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.List;

import market.Com.mapper.ComBaseInfoMapper;
import market.Com.mapper.PbModelDbMapper;
import market.Com.pb.DBUtil;
import market.Com.pb.DBUtilForYLSJ;
import market.Com.service.PbModelDbService;
import market.Com.vo.CommonPage;
import market.Com.vo.PbModelDb;
import market.Com.vo.ResultModel;
import market.Lms.Warehouse.vo.IfRawMtrCoilM;
import market.Lms.Warehouse.vo.IfRawMtrCoilPfmc;
import market.Qms.qcm.vo.QcmJhyPhyresult;
import market.Qms.qcm.vo.QcmJhySampleConsignD;
import market.Qms.qcm.vo.QcmJhySampleConsignDItem;

import com.hnshituo.basic.service.impl.BaseServiceImpl;
import com.hnshituo.basic.spring.remoting.annotation.RemoteService;


@RemoteService(path="PbModelDbService")
public class PbModelDbServiceImpl extends BaseServiceImpl<PbModelDb,Object> implements PbModelDbService {
	//--------------------2017-10后新增的部分，若完成后则删除原有的部分----------------------------
	
	

	/**
	 * 质量判定-卡量检测-获取检验结果下拉框数据
	 * */
	public ResultModel findComBaseInfoKLJYJG(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoKLJYJG());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	
	/**
	 * 检验委托管理-获取取样频次下拉框信息
	 * */
	public ResultModel findComBaseInfoQYPC(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoQYPC());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	
	/**
	 * 检验委托管理-获取取样类型下拉框信息
	 * */
	public ResultModel findComBaseInfoQYLX(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoQYLX());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	/**
	 * 检验委托管理-获取认证机构下拉框信息
	 * */
	public ResultModel findComBaseInfoRZJG(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoRZJG());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	
	/**
	 * 检验委托管理-获取试样类型下拉框信息
	 * */
	public ResultModel findComBaseInfoSYLX(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoSYLX());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	/**
	 * 质量判定-获取检查结果下拉框数据
	 * */	
	public ResultModel findComBaseInfoTR(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoTR());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	/**
	 * 质量判定-获取缺陷位置下拉框数据
	 * */	
	public ResultModel findComBaseInfoLOC(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoLOC());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	
	/**
	 * 质量判定-材质判定管理-获取判定结果下拉框数据
	 * */	
	public ResultModel findComBaseInfoJG(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoJG());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	/**
	 * 质量判定-材质判定管理-获取浅红色代码值
	 * */	
	public ResultModel findComBaseInfoRED(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoRED());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	/**
	 * 质量判定-材质判定管理-获取浅绿色代码值
	 * */	
	public ResultModel findComBaseInfoGREEN(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoGREEN());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	/**
	 * 获取节点下的子数据
	 * 在对象的id参数中传入上级编号值即可
	 * */
	public ResultModel findComBaseInfoCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			if(sum.getMemo1()!=null&&!"".equals(sum.getMemo1())){
				if(sum.getMemo1().indexOf(",")>=0){
					List<CommonPage<PbModelDb>> lcpp=new ArrayList<CommonPage<PbModelDb>>();

					for(String pid:sum.getMemo1().split(",")){
						CommonPage<PbModelDb> cpp=new CommonPage<PbModelDb>();
						cpp.setMemo1(pid);
						cpp.setObjectList(this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb(sum.getMemo1()));
						lcpp.add(cpp);
					}
				}else{
					List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb(sum.getMemo1());
					rm.setData(lpm);
				}

			}
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}

		return rm;
	}

	/**
	 * 最终用户列表
	 * */
	public ResultModel findFinalCustomerCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findFinalCustomerCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}

	/**
	 * 某个客户下的最终用户列表
	 * */
	public ResultModel findCustomerObruInfoCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findCustomerObruInfoCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!"+ex.getMessage());
		}
		return rm;
	}
	
	/**
	 * 销售组织，即公司部门
	 * */
	public ResultModel findDepartmentCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findDepartmentCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}

	/**
	 * 获取公司下拉框数据
	 * 在对象的memo1参数中传入 valid_flag的值即可
	 * */
	public ResultModel findSlmCustomerInfoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findSlmCustomerInfoCmdDb("");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	public ResultModel findSlmCustomerInfoCmdDb2(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=new ArrayList<PbModelDb>();
			if (sum.getMemo1()!=null) {
				lpm=this.getMapper(PbModelDbMapper.class).findByName(sum.getMemo1());
			}else{
				lpm=this.getMapper(PbModelDbMapper.class).findSlmCustomerInfoCmdDb("");
				
			}
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}

	/**
	 * 获取行政区域数据，根据父找子级
	 * */
	public ResultModel findSlmBaseRegionCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findSlmBaseRegionCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}

	//根据长度得到国家
	public ResultModel findSlmBaseRegionCountyCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findSlmBaseRegionCountyCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 指定产线
	 * memo1客户编号，memo2产品编号
	 * */
	public ResultModel findIdenPlineCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findIdenPlineCmdDb(sum.getMemo1(),sum.getMemo2());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 查询客户的收货单位
	 * memo1客户编号
	 * */
	public ResultModel findReciverUnitCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findReciverUnitCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 查询收货单位下的收货地址
	 * memo1客户编号
	 * */
	public ResultModel findReciverAddressCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findReciverAddressCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取销售区域数据，根据父找子级
	 * */
	public ResultModel findSlmBaseSaleareaInfoCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findSlmBaseSaleareaInfoCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取销售区域数据，根据父找子级
	 * */
	public ResultModel findSlmBaseSaleareaInfosCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findSlmBaseSaleareaInfosCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}

	/**
	 * 收货单位
	 * */
	public ResultModel findSlmCustomerObruInfoCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findSlmCustomerObruInfoCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 行政区域属性
	 * */
	public ResultModel findRegionAttributeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1001");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 销售类型
	 * */
	public ResultModel findSaleTypeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1002");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 长度单位
	 * */
	public ResultModel findLengthUnitCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1003");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 客户性质
	 * */
	public ResultModel CustomerNatureCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1004");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 客户等级
	 * */
	public ResultModel findCutomerLevelCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1005");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 客户行业
	 * */
	public ResultModel findCutomerIndustryCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1006");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 客户类型
	 * */
	public ResultModel findCutomerTypeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1007");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 贸易类型
	 * */
	public ResultModel findTradeTypeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1008");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 银行信用等级
	 * */
	public ResultModel findBankCreditCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1009");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 商业信用等级
	 * */
	public ResultModel findBusinessCreditCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1010");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 风险等级
	 * */
	public ResultModel findRiskClassCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1011");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 员工规模
	 * */
	public ResultModel findPersonClassCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1033");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 费用承担方式
	 * */
	public ResultModel findCostModelCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1012");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 职位信息
	 * */
	public ResultModel findPersonPositionCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1013");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 学历
	 * */
	public ResultModel findEducationCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1014");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 职称信息
	 * */
	public ResultModel findPersonTitleCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1015");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	
	/**
	 * 专线名称
	 * */
	public ResultModel findDedicatedlineCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1032");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 机场
	 * @return
	 */
	public ResultModel findBaseAirportCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findBaseAirportCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 站点
	 * @return
	 */
	public ResultModel findBaseRailStationCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findBaseRailStationCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 港口
	 * @return
	 */
	public ResultModel findBaseShipPortCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findBaseShipPortCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 品名
	 * @return
	 */
	public ResultModel findPrododeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findPrododeCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 工序
	 * @return
	 */
	public ResultModel findProcessCodeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findProcessCodeCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 产线
	 * memo1 工序编号
	 * @return
	 */
	public ResultModel findPlineCodeCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findPlineCodeCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	//--------------------2017-10 end---------------------------------------------------------------

	/**
	 * 合同类型编号1016 协议合同、现货合同、期货合同
	 * */
	public ResultModel findContractTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1016");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 合同贸易类型编号1017 内贸、外贸
	 * */
	public ResultModel findTradeTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1017");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 计价方式编号1018 随行就市，锁价
	 * */
	public ResultModel findPriceTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1018");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 币种编号1019 美元、人民币、欧元
	 * */
	public ResultModel findCurrencyNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1019");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 付款方式编号1020 N/A，现金，六个月承兑，三月个承兑，电汇，按协议结算
	 * */
	public ResultModel findPaymentTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1020");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 合同状态编号1021 1、编辑；2、待审；3生效；4、结案
	 * */
	public ResultModel findContractFlagNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1021");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 定价方式编号1022 协议价、招标价、采购价
	 * */
	public ResultModel findMakePriceTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1022");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 冶金规范类型编号0019 冶金规范码带过来
	 * */
	public ResultModel findMscTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("0019");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 计量单位编号1003 毫米、厘米、分米、米
	 * */
	public ResultModel findQuantityUnitNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1003");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 计重方式编号1023  吨、KG、
	 * */
	public ResultModel findWeightTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1023");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 定尺方式编号1024 
	 * */
	public ResultModel findFixedLengthTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1024");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 切边方式编号1025
	 * */
	public ResultModel findCutEdgeTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1025");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 合同行状态编号1026 编辑、技术评审中、技术评审通过、技术评审退回、
	 * （价格评审中、价格评审通过、价格评审退回、主管审批通过、主管审批退回、经理审批通过、经理审批退回、合同生效）
	 * 待审批、审批中、生效、结案、注销
	 * */
	public ResultModel findLineFlagNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1026");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 付款节点编号1027 排产前、发货前、发货后、货物交齐后、发票开出后、货到后、质保期、发票开出前
	 * */
	public ResultModel findPaymentPointNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1027");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 付款类型编号1028 预付款、排产款、交货款
	 * */
	public ResultModel findPaymentRatioTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1028");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 单位编号1029 
	 * */
	public ResultModel findUnitNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1029");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 范本条目编号1030
	 * */
	public ResultModel findLineNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1030");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 条目分类编号1031
	 * */
	public ResultModel findLineTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1031");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 订单状态编号1034
	 * */
	public ResultModel findOrderFlagNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1034");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 产品形态编号1035
	 * */
	public ResultModel findProdFigureNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1035");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 客户终端性质1036
	 * */
	public ResultModel findCustomerTagendNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1036");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 进出账类型1037
	 * */
	public ResultModel findInOutTypeNoCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("1037");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 成分要求-化学元素
	 * */
	public ResultModel findChemCodeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findChemCodeCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 成分要求-限制规格代码4003
	 * 外径、壁厚、径壁比、长、厚、宽
	 * */
	public ResultModel findSizeCodeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4003");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 探伤要求-材质检验项 COM_BASE_PHY
	 * */
	public ResultModel findPhyCodeSCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findPhyCodeSCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 探伤要求-探伤位置4020
	 * */
	public ResultModel findPositionCodeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4020");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 探伤要求-探伤参考标准4021
	 * */
	public ResultModel findStdDescCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4021");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 探伤要求-探伤级别4022
	 * */
	public ResultModel findLvDescCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4022");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 材质要求-材质检验项代码（大类）COM_BASE_PHY_B
	 * */
	public ResultModel findPhyCodeLCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findPhyCodeLCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 材质要求-材质检验项代码（中类）COM_BASE_PHY_C
	 * */
	public ResultModel findPhyCodeMCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findPhyCodeMCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 材质要求-试验方向COM_BASE_PHY_R_ITEM，COM_BASE_PHY_ITEM跟PHY_CODE_M
	 * 参数memo1为试样组PHY_CODE_M
	 * */
	public ResultModel findItemCodeDCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findItemCodeDCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 材质要求-试验温度绑定COM_BASE_PHY_R_ITEM，COM_BASE_PHY_ITEM跟PHY_CODE_S
	 * 参数memo1为试样组PHY_CODE_S
	 * */
	public ResultModel findItemCodeTCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findItemCodeTCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 材质要求-试验尺寸绑定COM_BASE_PHY_R_ITEM，COM_BASE_PHY_ITEM，跟PHY_CODE_M
	 * 参数memo1为试样组PHY_CODE_M
	 * */
	public ResultModel findItemCodeSCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findItemCodeSCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 公差要求-公差项4040
	 * */
	public ResultModel findBiasCodeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4040");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 公差要求-精度等级4041
	 * */
	public ResultModel findLvCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4041");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 公差要求-精度类型4112
	 * */
	public ResultModel findLvTypeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4112");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 供应商5012
	 * */
	public ResultModel findSupplierCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("5012");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 客户附加要求
	 * memo1传编号
	 * */
	public ResultModel findAskItemCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findAskItemCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 接收单位 从CORE_AUTH_DEPARTMENT表获取
	 * */
	public ResultModel findRevFacCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findRevFacCmdDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 接收仓库     
	 * 2017.11.21 龙文航添加
	 * */
	public ResultModel findRevStoCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findRevStoCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 区域     
	 * 2017.11.22 龙文航添加
	 * memo1传storageattr
	 * */
	public ResultModel findAreaCmbDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findAreaCmbDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 货位
	 * 2017.11.23 龙文航添加
	 * memo1传BUTTRESSNO
	 * */
	public ResultModel findGoodsLocCmbDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findGoodsLocCmbDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取所有牌号信息
	 * */
	public ResultModel findSteelInfoCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findSteelInfoCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取包装等级 4006
	 * 包装要求
	 * */
	public ResultModel findPackgerLevelCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4006");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 产品大类 4049
	 * */
	public ResultModel findProductBigTypeCmdDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4049");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 标准号
	 * */
	public ResultModel findSTDInfoCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findSTDInfoCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 获取认证机构 4095
	 * 
	 * */
	public ResultModel findCertificationbodyCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4095");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取式样类型 4094
	 * 
	 * */
	public ResultModel findSpecimentypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4094");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取取样类型 4081
	 * 
	 * */
	public ResultModel findSamplingtypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4081");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取检验大项
	 * 
	 * */
	public ResultModel findTestlargeitemsCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findTestlargeitemsCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取试样组信息
	 * 
	 * */
	public ResultModel findSamplegroupinformationCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findSamplegroupinformationCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取检验项
	 * 
	 * */
	public ResultModel findTestitemsCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findTestitemsCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取工序
	 * 
	 * */
	public ResultModel findProcessCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findProcessCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 获取工序点
	 * 
	 * */
	public ResultModel findProcessDianCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findProcessDianCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取工序点类型
	 * 
	 * */
	public ResultModel findProcessLXCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4032");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取二级工序分类
	 * 
	 * */
	public ResultModel findProcessCCategorymbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4072");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 传入父类编码
	 * 管理部门(科室)查询
	 * */
	public ResultModel findAuthDepartmentCmdDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findAuthDepartmentCmdDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取仓库地点 5070
	 * 
	 * */
	public ResultModel findStoPlaceCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("5070");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取仓库类型 5001
	 * 
	 * */
	public ResultModel findStorageTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("5001");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取仓库属性
	 * */
	public ResultModel findStorageattrCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("5002");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取区域属性 5003
	 * 
	 * */
	public ResultModel findAreaAttrCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("5003");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取承运单位 5060
	 * */
	public ResultModel findTransUnitNoCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("5060");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 班次
	 * */
	public ResultModel findWrkOrdCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=new ArrayList<PbModelDb>();
			PbModelDb pb0=new PbModelDb();
			pb0.setId("0");
			pb0.setText("常白班");
			lpm.add(pb0);
			
			PbModelDb pb1=new PbModelDb();
			pb1.setId("1");
			pb1.setText("晚班");
			lpm.add(pb1);
			
			PbModelDb pb2=new PbModelDb();
			pb2.setId("2");
			pb2.setText("早班");
			lpm.add(pb2);
			
			PbModelDb pb3=new PbModelDb();
			pb3.setId("3");
			pb3.setText("中班");
			lpm.add(pb3);
			
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 班组
	 * */
	public ResultModel findWrkGrpCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=new ArrayList<PbModelDb>();
			PbModelDb pb0=new PbModelDb();
			pb0.setId("0");
			pb0.setText("常白班");
			lpm.add(pb0);
			
			PbModelDb pb1=new PbModelDb();
			pb1.setId("1");
			pb1.setText("甲班");
			lpm.add(pb1);
			
			PbModelDb pb2=new PbModelDb();
			pb2.setId("2");
			pb2.setText("乙班");
			lpm.add(pb2);
			
			PbModelDb pb3=new PbModelDb();
			pb3.setId("3");
			pb3.setText("丙班");
			lpm.add(pb3);
			
			PbModelDb pb4=new PbModelDb();
			pb4.setId("4");
			pb4.setText("丁班");
			lpm.add(pb4);
			
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 分条断带原因
	 * */
	public ResultModel findTapebreakCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("385101");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 入库类型
	 * @return
	 */
	public ResultModel findTapebreakCmbDbs(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("5004");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 出库类型
	 * @return
	 */
	public ResultModel findOutCmbDbs(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("5005");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 车号
	 * @param sum
	 * @return
	 */
	public ResultModel findSlmLadingBillCar(CommonPage<PbModelDb> sum) {
		ResultModel rm =new ResultModel();
		try {
			List<PbModelDb> pmd =this.getMapper(PbModelDbMapper.class).findSlmLadingBillCar(sum.getMemo1());
			rm.setData(pmd);
			rm.setState("200");
		} catch (Exception e){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取生成卷的厚度范围
	 * @return
	 */
	public ResultModel findPlnThickRangeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("2001");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * chaxunzuibeiweizhi
	 * @return
	 */
	public ResultModel findCombaseinfozbwz() {
		ResultModel rm =new  ResultModel();
		try {
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findCombaseinfozbwz();
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception e) {
			// TODO: handle exception
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取分条成品宽度偏差
	 * @return
	 */
	public ResultModel findMesProductWidthCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findDeviationByBase_code("386");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取oracle系统的时间
	 * @return
	 */
	public ResultModel findDbTime(){
		ResultModel rm=new ResultModel();
		try{
			rm.setData(this.getMapper(PbModelDbMapper.class).findDbTime());
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 交接班管理
	 * 查询所有机台
	 * @return
	 */
	public ResultModel findShiftMachineCmbDb() {
		ResultModel rm =new  ResultModel();
		try {
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findShiftMachineCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception e) {
			// TODO: handle exception
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 交接班管理
	 * 查询所有岗位
	 * @return
	 */
	public ResultModel findShiftPostCmbDb() {
		ResultModel rm =new  ResultModel();
		try {
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findShiftPostCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception e) {
			// TODO: handle exception
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 交接班管理
	 * 查询所有消耗项目名称,消耗项目单位 
	 * @return
	 */
	public ResultModel findShiftItemCmbDb() {
		ResultModel rm =new  ResultModel();
		try {
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findShiftItemCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 交接班管理
	 * 类别
	 * @return
	 */
	public ResultModel findShiftTypeDb() {
		ResultModel rm =new  ResultModel();
		try {
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findShiftTypeDb();
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 *交接班管理 通过点检类别获取点检项目名称
	 * memo1:点检类别
	 * @return
	 */ 
	public ResultModel findShiftItemCkCmbDb(CommonPage<PbModelDb> sum) {
		ResultModel rm =new  ResultModel();
		try {
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findShiftItemCkCmbDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取度量类型
	 * @return
	 */
	public ResultModel findPmsUomsTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6001");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取度量配置表数据
	 * memo1 不为空则根据状态查询
	 * @return
	 */
	public ResultModel findPmsUomsCmbDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findPmsUomsCmbDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 获取物料标准信息
	 * memo1 不为空则根据状态查询
	 * @return
	 */
	public ResultModel findPmsBsStandardsCmbDb(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findPmsBsStandardsCmbDb(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 供方区分
	 * @return
	 */
	public ResultModel findPmsSuppTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6003");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 信用等级
	 * @return
	 */
	public ResultModel findPmsSuppBLvlCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6004");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 货币种类
	 * @return
	 */
	public ResultModel findPmsSuppPriceCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6005");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 税率
	 * @return
	 */
	public ResultModel findPmsSuppRateCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6006");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 合作关系等级
	 * @return
	 */
	public ResultModel findPmsSuppLevelCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6007");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 证书类型
	 * @return
	 */
	public ResultModel findPmsSuppCertificateTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6008");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 条款分类类型
	 * @return
	 */
	public ResultModel findPmsSuppProvisionsTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6009");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 适用合同类型
	 * @return
	 */
	public ResultModel findPmsSuppOrdersTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6010");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 模板分类类型
	 * @return
	 */
	public ResultModel findPmsSuppModeTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6011");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 金额分类类型
	 * @return
	 */
	public ResultModel findPmsSuppMoneyTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6012");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 运输条款类型
	 * @return
	 */
	public ResultModel findPmsSuppConveyProTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6013");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 交货量差类型类型
	 * @return
	 */
	public ResultModel findPmsSuppDeliveryQdTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6014");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	
	/**
	 * 收货方式
	 * @return
	 */
	public ResultModel findPmsSuppReceiptWaysProTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6015");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	

	/**
	 * 包装方式
	 * @return
	 */
	public ResultModel findPmsSuppPackagingWaysProTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6016");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 验证方式
	 * @return
	 */
	public ResultModel findPmsSuppConfirmWaysProTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6017");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 检验分类方式
	 * @return
	 */
	public ResultModel findPmsSuppCheckoutWaysProTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6018");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 质量等级
	 * @return
	 */
	public ResultModel findPmsSuppQualityRankProTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6019");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 付款方式
	 * @return
	 */
	public ResultModel findPmsSuppPayWaysTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6020");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	/**
	 * 结算类别
	 * @return
	 */
	public ResultModel findPmsSuppBalanceWaysTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6021");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 运输方式
	 * @return
	 */
	public ResultModel findPmsSuppConveyWaysTypeCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6022");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 开平计划状态编码
	 * @return
	 */
	public ResultModel findCuttoLengthPlanCode() {
		ResultModel rm = new ResultModel();
		try {
			List<PbModelDb> lpm = this.getMapper(PbModelDbMapper.class).findPlanStatusCode("开平");
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception ex) {
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 从产品分类表(PUR_MAT_CLASS)中获取资材备件库产品分类显示在产品分类下拉列表中
	 * 入库类型(5004)
	 * @return
	 */
	public ResultModel findPurMatClassMcCmbDb() {
		ResultModel rm = new ResultModel();
		try {
			List<PbModelDb> lpm = this.getMapper(PbModelDbMapper.class).findPurMatClassCmbDb("5004");
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception ex) {
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 从产品分类表(PUR_MAT_CLASS)中获取资材备件库产品分类显示在产品分类下拉列表中
	 * 
	 * @return
	 */
	public ResultModel findProKind() {
		ResultModel rm = new ResultModel();
		try {
			List<PbModelDb> lpm = this.getMapper(PbModelDbMapper.class).doFindProKind();
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception ex) {
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**仓库垛位配置表(YDM_BASE_BUTTRESSCONFIG)中获取资材备件库对应的所有区域信息
	 *@param memo1传storageattr
	 *@return
	 */
	public ResultModel findYdmBbCmbDb(CommonPage<PbModelDb> cp){
		ResultModel rm=new ResultModel();
		try {
			List<PbModelDb> pm=this.getMapper(PbModelDbMapper.class).findYdmBbCmbDb(cp.getMemo1());
			rm.setData(pm);
			rm.setState("200");
		} catch (Exception ex) {
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败！");
		}
		return rm;
	}
	/**
	 * 从度量单位配置表(PUR_BS_UOMS)中获取度量单位在单位下拉列表中
	 */
	public ResultModel findPurBsCmbDb(){
		ResultModel rm=new ResultModel();
		try {
			List<PbModelDb> pm=this.getMapper(PbModelDbMapper.class).findPurBsCmbDb();
			rm.setData(pm);
			rm.setState("200");
		} catch (Exception ex) {
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败！");
		}
		return rm;
	}
	/**
	 * 从供应商基础信息表(PUR_SUPP_M)中获取资材备件供应商显示在供应商下拉列表中
	 * memo1 传入产品分类编码
	 * @return
	 */
	public ResultModel findPurSuppMCmbDb() {
		ResultModel rm = new ResultModel();
		try {
			List<PbModelDb> lpm = this.getMapper(PbModelDbMapper.class).findPurSuppMCmbDb();
			rm.setData(lpm);
			rm.setState("200");
		} catch (Exception ex) {
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	/**
	 * 适用采购需求分类
	 * @return
	 */
	public ResultModel findPmsDemandQuery(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6025");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 适用采购紧急程度分类
	 * @return
	 */
	public ResultModel findPmsEmergency(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6026");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 适用采购预算分类
	 * @return
	 */
	public ResultModel findPmsBudgetary(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6023");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 适用采购费用类型
	 * @return
	 */
	public ResultModel findCost(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6024");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 适用采购用途类型
	 * @return
	 */
	public ResultModel findPurpose(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6027");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 适用采购方式分类
	 * @return
	 */
	public ResultModel findPurMethod(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6028");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 适用采购评标标准分类
	 * @return
	 */
	public ResultModel findPurBid(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("6029");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	/**
	 * 查询if_jhy_sample_info_m表数据
	 */
	public QcmJhySampleConsignD findInfoM(String sta,String smp){
		Connection conn = null;
		Statement st = null;
		QcmJhySampleConsignD qcm=new QcmJhySampleConsignD();
		String strSql="select * from jhyuser.if_jhy_sample_info_m where status=? and smp_no=?";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			 ps.setString(1, sta);
			 ps.setString(2, smp);
			ResultSet rs = ps.executeQuery();
			//得到数据
			while(rs.next()){
				
				qcm.setSmp_no(rs.getString("SMP_NO"));
				qcm.setStatus(rs.getString("STATUS"));
				qcm.setSpecimen_no(rs.getString("SPECIMEN_NO"));
			}
			
			// 执行批处理sql 
			st.executeBatch();
			
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return qcm;
	}
	/**
	 * 修改if_jhy_sample_info_m表状态
	 */
	public void upStatus(String sta,String smp,String spe){
		Connection conn = null;
		Statement st = null;
		List<QcmJhySampleConsignD> listd=new ArrayList<>();
		String strSql="update jhyuser.if_jhy_sample_info_m set status=? where smp_no=? and SPECIMEN_NO=?";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
	         PreparedStatement ps=conn.prepareStatement(strSql);
	         ps.setString(1, sta);
	         ps.setString(2, smp);
	         ps.setString(3, spe);
			 ps.executeUpdate();
			// 执行批处理sql 
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	public QcmJhyPhyresult findResultInfo(String spe){
		Connection conn = null;
		Statement st = null;
		QcmJhyPhyresult qcm=new QcmJhyPhyresult();
		String strSql="select * from if_jhy_phy_result where SPECIMEN_NO=?";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			 ps.setString(1, spe);
			ResultSet rs = ps.executeQuery();
			//得到数据
			while(rs.next()){
			    qcm.setSpecimen_no(rs.getString("SPECIMEN_NO"));
			    qcm.setSeq(rs.getLong("SEQ"));
			    qcm.setTest_qty(rs.getLong("TEST_QTY"));
			    qcm.setPhy_code_l(rs.getString("PHY_CODE_L"));
			    qcm.setPhy_name_l(rs.getString("PHY_NAME_L"));
			    qcm.setPhy_code_m(rs.getString("PHY_CODE_M"));
			    qcm.setPhy_name_m(rs.getString("PHY_NAME_M"));
			    qcm.setPhy_code_s(rs.getString("PHY_CODE_S"));
			    qcm.setPhy_name_s(rs.getString("PHY_NAME_S"));
			    qcm.setItem_code_d(rs.getString("ITEM_CODE_D"));
			    qcm.setItem_name_d(rs.getString("ITEM_NAME_D"));
			    qcm.setItem_code_t(rs.getString("ITEM_CODE_T"));
			    qcm.setItem_name_t(rs.getString("ITEM_NAME_T"));
			    qcm.setItem_code_s(rs.getString("ITEM_CODE_S"));
			    qcm.setItem_name_s(rs.getString("ITEM_NAME_S"));
			    qcm.setVal1(rs.getString("VAL1"));
			    qcm.setVal2(rs.getString("VAL2"));
			    qcm.setVal3(rs.getString("VAL3"));
			    qcm.setGuid(rs.getString("GUID"));
			    qcm.setCreate_name(rs.getString("CREATE_NAME"));
			    qcm.setCreate_time(rs.getDate("CREATE_TIME"));
			}
			
			// 执行批处理sql 
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return qcm;
	}
	public void insertResultInfo(QcmJhySampleConsignDItem qjr){
		Connection conn = null;
		Statement st = null;
		QcmJhySampleConsignDItem qcm=new QcmJhySampleConsignDItem();
		String strSql="insert into IF_JHY_SAMPLE_INFO_D where values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			 ps.setString(1, qjr.getSpecimen_no());
			 ps.setLong(2, qjr.getSeq());
			 ps.setString(3, qjr.getPhy_code_l());
			 ps.setString(4, qjr.getPhy_name_l());
			 ps.setString(5, qjr.getPhy_code_m());
			 ps.setString(6, qjr.getPhy_name_m());
			 ps.setString(7, qjr.getPhy_code_s());
			 ps.setString(8, qjr.getPhy_name_s());
			 ps.setString(9, qjr.getItem_code_d());
			 ps.setString(10, qjr.getItem_name_d());
			 ps.setString(11, qjr.getItem_code_t());
			 ps.setString(12, qjr.getItem_name_t());
			 ps.setString(13, qjr.getItem_code_s());
			 ps.setString(14, qjr.getItem_name_s());
			 ps.setString(15, qjr.getUnti());
			 ps.setString(16, qjr.getRound_off_rules_code());
			 ps.setString(17, qjr.getRound_off_rules_name());
			 ps.setLong(18, qjr.getRound_off_digits());
			 ps.setString(19, qjr.getCreate_name());
			 ps.setDate(20, (Date) qjr.getCreate_time());
			 ps.executeUpdate();
			
			
			// 执行批处理sql 
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		
	}
	/**
	 * 查询IF_JHY_SAMPLE_INFO_M
	 * @param qjr
	 */
	public boolean findMSample(String smp){
		Connection conn = null;
		Statement st = null;
		boolean flag=false;
		
		String strSql="select * from IF_JHY_SAMPLE_INFO_M where SPECIMEN_NO=?";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			ps.setString(1, smp);
			ResultSet rs=ps.executeQuery();
			if (rs.next()) {
				flag=true;
			}
			// 执行批处理sql 
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			System.out.println(ex);
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return flag;
	}
	/**
	 * 查询IF_JHY_SAMPLE_INFO_D
	 * @param qjr
	 */
	public boolean findDSample(String spe){
		Connection conn = null;
		Statement st = null;
		boolean flag=false;
		
		String strSql="select * from IF_JHY_SAMPLE_INFO_M where SPECIMEN_NO=?";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			ps.setString(1, spe);
			ResultSet rs=ps.executeQuery();
			if (rs.next()) {
				flag=true;
			}
			// 执行批处理sql 
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			System.out.println(ex);
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return flag;
	}
	/**
	 * 把信息插入IF_JHY_SAMPLE_INFO_D
	 * @param qjr
	 * @throws Exception 
	 */
	public int insertInfoForD(QcmJhySampleConsignDItem qjr,java.util.Date da) throws Exception{
		Connection conn = null;
		Statement st = null;
		QcmJhySampleConsignDItem qcm=qjr;
		int a=0;
		String strSql="insert into IF_JHY_SAMPLE_INFO_D  values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			 ps.setString(1, qjr.getSpecimen_no());
			 ps.setLong(2, qjr.getSeq());
			 ps.setString(3, qjr.getPhy_code_l());
			 ps.setString(4, qjr.getPhy_name_l());
			 ps.setString(5, qjr.getPhy_code_m());
			 ps.setString(6, qjr.getPhy_name_m());
			 ps.setString(7, qjr.getPhy_code_s());
			 ps.setString(8, qjr.getPhy_name_s());
			 ps.setString(9, qjr.getItem_code_d());
			 ps.setString(10, qjr.getItem_name_d());
			 ps.setString(11, qjr.getItem_code_t());
			 ps.setString(12, qjr.getItem_name_t());
			 ps.setString(13, qjr.getItem_code_s());
			 ps.setString(14, qjr.getItem_name_s());
			 ps.setString(15, qjr.getUnti());
			 ps.setString(16, null);
			 ps.setString(17, null);
			 ps.setLong(18, 0);
			 ps.setString(19, qjr.getCreate_name());
			 ps.setTimestamp(20, new Timestamp(da.getTime()));
			 ps.setString(21, qjr.getPhy_item_code());
			 a=ps.executeUpdate();
			// 执行批处理sql 
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			System.out.println(ex);
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
				throw new Exception();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return a;
	}
	/**
	 * 把信息插入IF_JHY_SAMPLE_INFO_M
	 * @param qjr
	 */
	public int insertInfoForM(QcmJhySampleConsignD qjr,String steel_code,String steel_name,String username,java.util.Date d){
		Connection conn = null;
		Statement st = null;
		int a=0;
		QcmJhySampleConsignD qcm=qjr;
		String strSql="insert into IF_JHY_SAMPLE_INFO_M values(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			 ps.setString(1, qcm.getSmp_no());
			 ps.setString(2, qcm.getSpecimen_no());
			 ps.setString(3, qcm.getHeat_no());
			 ps.setString(4, qcm.getBatch_no());
			 ps.setString(5, qcm.getInspection_lot());
			 ps.setString(6, qcm.getFreq_code());
			 ps.setString(7, qcm.getFreq_name());
			 ps.setString(8, qcm.getMaterial_no());
			 ps.setString(9, qcm.getSmp_type_code());
			 ps.setString(10, qcm.getSmp_type_name());
			 ps.setString(11, qcm.getConsign_no());
			 ps.setLong(12, qcm.getConsign_no_seq());
			 ps.setLong(13, qcm.getTest_qty());
			 ps.setLong(14, qcm.getSmp_qty());
			 ps.setString(15, qcm.getBoard_no());
			 ps.setString(16, qcm.getOld_consign_no());
			 ps.setString(17, qcm.getPline_code());
			 ps.setString(18, qcm.getPline_name());
			 ps.setString(19, qcm.getStatus());
			 ps.setString(20, null);
			 ps.setString(21, null);
			 ps.setString(22, "999");
			 ps.setString(23, "测试");
			 ps.setString(24,steel_code);
			 ps.setString(25, steel_name);
			 ps.setLong(26, 0);
			 ps.setLong(27, 0);
			 ps.setLong(28, 0);
			 ps.setString(29, username);
			 ps.setTimestamp(30, new Timestamp(d.getTime()));
			 ps.setString(31, null);
			 ps.setDate(32, null);
			 ps.setString(33, null);
			a=ps.executeUpdate();
			// 执行批处理sql 
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			System.out.println(ex);
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return a;
	}
	/**
	 * 删除D表数据
	 * @param spe
	 * @param seq
	 * @return
	 */
	public int deleteDSample(String spe,long seq){
		Connection conn = null;
		Statement st = null;
		int a=0;
		String strSql="delete IF_JHY_SAMPLE_INFO_D where SPECIMEN_NO=? and SEQ=?";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			ps.setString(1, spe);
			ps.setLong(2, seq);
			System.out.println(strSql);
			a=ps.executeUpdate();
			// 执行批处理sql 
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			System.out.println(ex);
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return a;
	}
	/**
	 * 删除M表中的数据
	 * @param spe
	 * @param seq
	 * @return
	 */
	public int deleteMSample(String smp,String spe){
		Connection conn = null;
		Statement st = null;
		int a=0;
		String strSql="delete if_jhy_sample_info_m where smp_no=? and specimen_no=?";
		try{
			conn = DBUtil.getConnection();
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			ps.setString(1, smp);
			ps.setString(2, spe);
			System.out.println(strSql);
			a=ps.executeUpdate();
			// 执行批处理sql 
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			System.out.println(ex);
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return a;
	}
	
	/**
	 *资材备件，出库管理(计划)，机台信息
	 * @return
	 */
	public ResultModel findLmsEquipmentMachineCmbDb(){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("5362");
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!");
		}
		return rm;
	}
	
	
	public ResultModel findQBFS(){
	     ResultModel rm=new ResultModel();
	     try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findWithCondition(null, "SORT_CODE='1025'", null, 0, 0));
		} catch (Exception e) {
			// TODO: handle exception
		}
	     return rm;
		}
	
	/**
	 * 计划模块-计划编制-获取机台代码下拉框数据
	 * */
	public ResultModel findComBaseInfoJTBM(String sort_code){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(ComBaseInfoMapper.class).findComBaseInfoJTBM(sort_code));
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	
	/**
	 * 销售-结算单编制-新增-查询有对齐提单的客户
	 * */
	public ResultModel findCheckedBill(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(PbModelDbMapper.class).findCheckedBill());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败");
			e.printStackTrace();
		}
		return rm;
	}
	

/**
	 * 销售-销售计划-获取产品牌号分类
	 * */
	public ResultModel findSteelGroup(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(PbModelDbMapper.class).findSteelGroup());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败"+e.getMessage());
			e.printStackTrace();
		}
		return rm;
	}
	
	/**
	 * 销售-销售计划-获取交货状态
	 * */
	public ResultModel findDeliveryState(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(PbModelDbMapper.class).findDeliveryState());
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败"+e.getMessage());
			e.printStackTrace();
		}
		return rm;
	}
	
	/**
	 * 销售-销售计划-获取交货状态
	 * */
	public ResultModel findPlanClassNo(){
		ResultModel rm=new ResultModel();
		try {
			rm.setData(this.getMapper(PbModelDbMapper.class).findComBaseInfoCmdDb("4049"));
			rm.setState("200");
		} catch (Exception e) {
			rm.setState("500");
			rm.setMsgInfo("获取失败"+e.getMessage());
			e.printStackTrace();
		}
		return rm;
	}

	/**
	 * 查询原材料实绩信息
	 * @param connect 条件
	 * @param pageindex 页码
	 * @param pagesize 条数
	 * @return
	 */
	public List<IfRawMtrCoilM> getCoilMInfo(String connect,int pageindex,int pagesize){
		Connection conn = null;
		Statement st = null;
		List<IfRawMtrCoilM> liststr=new ArrayList<>();
		int a=0;
		String strSql="select * from (select w.*,rownum rm from (select * from if_raw_mtr_coil_m m where "+connect+" order by m.CREATE_TIME desc) w where 1=1 and rownum<="+pagesize+") where 1=1 and rm>"+pageindex;
		try{
			conn = DBUtilForYLSJ.getConnection();
			 System.out.println(strSql);
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			 ResultSet rs = ps.executeQuery();
			 while (rs.next()) {
				 IfRawMtrCoilM irm=new IfRawMtrCoilM();
				 irm.setCoilNo(rs.getString("COIL_NO"));
				 irm.setCoilSource(rs.getString("COIL_SOURCE"));
				 irm.setCoilSort(rs.getString("COIL_SORT"));
				 irm.setSupplierCode(rs.getString("SUPPLIER_CODE"));
				 irm.setSupplierName(rs.getString("SUPPLIER_NAME"));
				 irm.setHeatno(rs.getString("HEATNO"));
				 irm.setSmpNo(rs.getString("SMP_NO"));
				 irm.setPrdCode(rs.getString("PRD_CODE"));
				 irm.setPrdName(rs.getString("PRD_NAME"));
				 irm.setStdCode(rs.getString("STD_CODE"));
				 irm.setStdName(rs.getString("STD_NAME"));
				 irm.setSteelCode(rs.getString("STEEL_CODE"));
				 irm.setSteelName(rs.getString("STEEL_NAME"));
				 irm.setCoilThk(rs.getDouble("COIL_THK"));
				 irm.setCoilWdt(rs.getDouble("COIL_WDT"));
				 irm.setCoilLen(rs.getDouble("COIL_LEN"));
				 irm.setCoilInnDia(rs.getDouble("COIL_INN_DIA"));
				 irm.setCoilOutDia(rs.getDouble("COIL_OUT_DIA"));
				 irm.setCoilThrWgt(rs.getDouble("COIL_THR_WGT"));
				 irm.setCoilActWgt(rs.getDouble("COIL_ACT_WGT"));
				 irm.setProduceTime(rs.getString("PRODUCE_TIME"));
				 irm.setFlawCode1(rs.getString("FLAW_CODE1"));
				 irm.setFlawCode2(rs.getString("FLAW_CODE2"));
				 irm.setFlawCode3(rs.getString("FLAW_CODE3"));
				 irm.setFlawCode4(rs.getString("FLAW_CODE4"));
				 irm.setFlawCode5(rs.getString("FLAW_CODE5"));
				 irm.setFlawName1(rs.getString("FLAW_NAME1"));
				 irm.setFlawName2(rs.getString("FLAW_NAME2"));
				 irm.setFlawName3(rs.getString("FLAW_NAME3"));
				 irm.setFlawName4(rs.getString("FLAW_NAME4"));
				 irm.setFlawName5(rs.getString("FLAW_NAME5"));
				 irm.setChemDecRstCode(rs.getString("CHEM_DEC_RST_CODE"));
				 irm.setChemDecRstName(rs.getString("CHEM_DEC_RST_NAME"));
				 irm.setSurfaceDecRstCode(rs.getString("SURFACE_DEC_RST_CODE"));
				 irm.setSurfaceDecRstName(rs.getString("SURFACE_DEC_RST_NAME"));
				 irm.setSizeDecRstCode(rs.getString("SIZE_DEC_RST_CODE"));
				 irm.setSizeDecRstName(rs.getString("SIZE_DEC_RST_NAME"));
				 irm.setPfmcDecRstCode(rs.getString("PFMC_DEC_RST_CODE"));
				 irm.setPfmcDecRstName(rs.getString("PFMC_DEC_RST_NAME"));
				 irm.setWgtDecRstCode(rs.getString("WGT_DEC_RST_CODE"));
				 irm.setWgtDecRstName(rs.getString("WGT_DEC_RST_NAME"));
				 irm.setTotalDecRstCode(rs.getString("TOTAL_DEC_RST_CODE"));
				 irm.setTotalDecRstName(rs.getString("TOTAL_DEC_RST_NAME"));
				 irm.setStatus(rs.getString("STATUS"));
				 irm.setRemark(rs.getString("REMARK"));
				 irm.setCreateOpr(rs.getString("CREATE_OPR"));
				 irm.setCreateTime(rs.getTimestamp("CREATE_TIME"));
//				 irm.setOrderno(rs.getString("ORDERNO"));
//				 irm.setProdorderno(rs.getString("PRODORDERNO"));
//				 irm.setOrd_nm(rs.getString("ORD_NM"));
//				 irm.setInstr_coil_thk(rs.getString("INSTR_COIL_THK"));
//				 irm.setInstr_coil_wth(rs.getString("INSTR_COIL_WTH"));
//				 irm.setDliv_tp(rs.getString("DLIV_TP"));
//				 irm.setTrans_car_no(rs.getString("TRANS_CAR_NO"));
//				 irm.setPackagel(rs.getString("PACKAGEL"));
//				 irm.setDestpcd(rs.getString("DESTPCD"));
				 liststr.add(irm);
			}
			// 执行批处理sql 
			 System.out.println(strSql);
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			System.out.println(ex);
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return liststr;
	}
	/**
	 * 查询原材料实绩信息总条数
	 * @param connect 条件
	 * @param pageindex 页码
	 * @param pagesize 条数
	 * @return
	 */
	public int getCoilMInfocount(String connect){
		Connection conn = null;
		Statement st = null;
		List<IfRawMtrCoilM> liststr=new ArrayList<>();
		int a=0;
		String strSql="select * from if_raw_mtr_coil_m where "+connect;
		try{
			conn = DBUtilForYLSJ.getConnection();
			 System.out.println(strSql);
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			 ResultSet rs = ps.executeQuery();
			 while (rs.next()) {
				a++;
			}
			// 执行批处理sql 
			 System.out.println(strSql);
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			System.out.println(ex);
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return a;
	}
	public List<IfRawMtrCoilPfmc> getCoilPfmcBySmp(String smp_no){
		Connection conn = null;
		Statement st = null;
		List<IfRawMtrCoilPfmc> liststr=new ArrayList<>();
		int a=0;
		String strSql="select * from IF_RAW_MTR_COIL_PFMC where smp_no=?";//='"+smp_no+"'
		try{
			conn = DBUtilForYLSJ.getConnection();
			 System.out.println(strSql);
			conn.setAutoCommit(false);	// 更改JDBC事务的默认提交方式 
			st = conn.createStatement();
			 PreparedStatement ps=conn.prepareStatement(strSql);
			 ps.setString(1, smp_no);
			 ResultSet rs = ps.executeQuery();
			 while (rs.next()) {
				 IfRawMtrCoilPfmc irm=new IfRawMtrCoilPfmc();
				 irm.setSmpNo(rs.getString("SMP_NO"));
				 irm.setPfmcCode(rs.getString("PFMC_CODE"));
				 irm.setPfmcName(rs.getString("PFMC_NAME"));
				 irm.setPfmcValue(rs.getDouble("PFMC_VALUE"));
				 irm.setPfmcUnitCode(rs.getString("PFMC_UNIT_CODE"));
				 irm.setSmpNo(rs.getString("PFMC_UNIT_NAME"));
				 irm.setPfmcTypeCode(rs.getString("PFMC_TYPE_CODE"));
				 irm.setPfmcTypeName(rs.getString("PFMC_TYPE_NAME"));
				 irm.setInspectTime(rs.getString("INSPECT_TIME"));
				 irm.setRemark(rs.getString("REMARK"));
				 irm.setCreateOpr(rs.getString("CREATE_OPR"));
				 irm.setCreateTime(rs.getTimestamp("CREATE_TIME"));
				 liststr.add(irm);
			}
			// 执行批处理sql 
			 System.out.println(strSql);
			st.executeBatch();
			conn.commit();//提交JDBC事务 
			conn.setAutoCommit(true);// 恢复JDBC事务的默认提交方式 
			
		}catch(Exception ex){
			System.out.println(ex);
			try {
				if(conn!=null){
					if(!conn.isClosed()){
						conn.rollback();
						conn.setAutoCommit(true);
					}
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}finally{
			try {
				if(st!=null){
					st.clearBatch();
					st.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
			try {
				if(conn!=null){
					conn.close();
				}
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
		return liststr;
	}
	
	/**
	 * 
	 */
	public ResultModel doBaseProduct(CommonPage<PbModelDb> sum){
		ResultModel rm=new ResultModel();
		try{
			List<PbModelDb> lpm=this.getMapper(PbModelDbMapper.class).doBaseProduct(sum.getMemo1());
			rm.setData(lpm);
			rm.setState("200");
		}catch(Exception ex){
			rm.setState("500");
			rm.setMsgInfo("服务端异常，获取数据失败!"+ex.getMessage());
		}
		return rm;
	}
}

