 /***文档注释***********************************************
 * 作者               :                   宋燕辉
 * 创建日期      :                   2019.6.11
 * 描述               :                  轧机  pdipdo
 * 注意事项      :                   无
 * 遗留BUG :                   无
 * 修改日期      :                   
 * 修改人员      :                    
 * 修改内容      :                   
 ***********************************************************/
package market.Api.Mes.impl;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.List;

import market.Api.Lms.impl.LmsApiServiceImpl;
import market.Api.Mes.service.MesApiRollPdiPdoService;
import market.Api.Qms.impl.QmsApiServiceImpl;
import market.Com.mapper.ComBaseMachineMapper;
import market.Com.mapper.ComBaseSteelMapper;
import market.Com.pb.PropertiesUtils;
import market.Com.vo.ComBaseMachine;
import market.Com.vo.ComBaseSteel;
import market.Com.vo.CommonPage;
import market.Com.vo.ResultModel;
import market.Lms.Warehouse.mapper.YdmProductDetailMapper;
import market.Lms.Warehouse.mapper.YdmProductOutlistMapper;
import market.Lms.Warehouse.vo.YdmProductDetail;
import market.Lms.Warehouse.vo.YdmProductOutlist;
import market.Mes.Dev.impl.DevRollerPairMServiceImpl;
import market.Mes.Dev.mapper.DevRollerInfoMapper;
import market.Mes.Dev.mapper.DevRollerPairDMapper;
import market.Mes.Dev.mapper.DevRollerPairMMapper;
import market.Mes.Dev.vo.DevRollerInfo;
import market.Mes.Dev.vo.DevRollerPairD;
import market.Mes.Dev.vo.DevRollerPairM;
import market.Mes.Lengthwise.Plan.mapper.PlnMaterielDetailMapper;
import market.Mes.Lengthwise.Plan.vo.PlnMaterielDetail;
import market.Mes.OrderManager.Plan.mapper.PlnProdorderMapper;
import market.Mes.OrderManager.Plan.vo.PlnProdorder;
import market.Mes.Rolling.Performance.impl.MesRcmDServiceImpl;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2AnswerRevokeMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2AskOrdMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2AskPdiMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2EnergyMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2PdoDfcMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2PdoMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2PdoPassMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2PrdEndMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2PrdStrMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2RejectMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2RevokeMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2RllLoadDMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2RllLoadMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2RllRmvDMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2RllRmvMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L2StopMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3AnswerPdoMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3AnswerRejectMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3AnswerRevokeMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3NoneOrdMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3NonePdiMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3OrdCoilMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3OrdMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3PdiMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3RevokeMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01L3RollerMapper;
import market.Mes.Rolling.Performance.mapper.IfRoll01LogMapper;
import market.Mes.Rolling.Performance.mapper.MesRcmDMapper;
import market.Mes.Rolling.Performance.mapper.MesRcmDPassMapper;
import market.Mes.Rolling.Performance.mapper.MesRcmEnergyMapper;
import market.Mes.Rolling.Performance.mapper.MesRcmMMapper;
import market.Mes.Rolling.Performance.mapper.MesRcmStopMapper;
import market.Mes.Rolling.Performance.mapper.MesRcmTrcMapper;
import market.Mes.Rolling.Performance.vo.IfRoll01L2AnswerRevoke;
import market.Mes.Rolling.Performance.vo.IfRoll01L2AskOrd;
import market.Mes.Rolling.Performance.vo.IfRoll01L2AskPdi;
import market.Mes.Rolling.Performance.vo.IfRoll01L2Energy;
import market.Mes.Rolling.Performance.vo.IfRoll01L2Pdo;
import market.Mes.Rolling.Performance.vo.IfRoll01L2PdoDfc;
import market.Mes.Rolling.Performance.vo.IfRoll01L2PdoPass;
import market.Mes.Rolling.Performance.vo.IfRoll01L2PrdEnd;
import market.Mes.Rolling.Performance.vo.IfRoll01L2PrdStr;
import market.Mes.Rolling.Performance.vo.IfRoll01L2Reject;
import market.Mes.Rolling.Performance.vo.IfRoll01L2Revoke;
import market.Mes.Rolling.Performance.vo.IfRoll01L2RllLoad;
import market.Mes.Rolling.Performance.vo.IfRoll01L2RllLoadD;
import market.Mes.Rolling.Performance.vo.IfRoll01L2RllRmv;
import market.Mes.Rolling.Performance.vo.IfRoll01L2RllRmvD;
import market.Mes.Rolling.Performance.vo.IfRoll01L2Stop;
import market.Mes.Rolling.Performance.vo.IfRoll01L3AnswerPdo;
import market.Mes.Rolling.Performance.vo.IfRoll01L3AnswerReject;
import market.Mes.Rolling.Performance.vo.IfRoll01L3AnswerRevoke;
import market.Mes.Rolling.Performance.vo.IfRoll01L3NoneOrd;
import market.Mes.Rolling.Performance.vo.IfRoll01L3NonePdi;
import market.Mes.Rolling.Performance.vo.IfRoll01L3Ord;
import market.Mes.Rolling.Performance.vo.IfRoll01L3OrdCoil;
import market.Mes.Rolling.Performance.vo.IfRoll01L3Pdi;
import market.Mes.Rolling.Performance.vo.IfRoll01L3Revoke;
import market.Mes.Rolling.Performance.vo.IfRoll01L3Roller;
import market.Mes.Rolling.Performance.vo.IfRoll01L3RollerD;
import market.Mes.Rolling.Performance.vo.IfRollOrderView;
import market.Mes.Rolling.Performance.vo.IfRollRollerView;
import market.Mes.Rolling.Performance.vo.MesRcmD;
import market.Mes.Rolling.Performance.vo.MesRcmDPass;
import market.Mes.Rolling.Performance.vo.MesRcmEnergy;
import market.Mes.Rolling.Performance.vo.MesRcmM;
import market.Mes.Rolling.Performance.vo.MesRcmStop;
import market.Mes.Rolling.Performance.vo.MesRcmTrc;
import market.Mes.Rolling.Performance.vo.Roll0lL3NoView;
import market.Mes.Rolling.Plan.mapper.PlnRollingPlanDetailMapper;
import market.Mes.Rolling.Plan.mapper.PlnRollingPlanMapper;
import market.Mes.Rolling.Plan.vo.PlnRollingPlan;
import market.Mes.Rolling.Plan.vo.PlnRollingPlanDetail;
import market.Mes.Shift.mapper.MesShiftMMapper;
import market.Mes.Shift.vo.MesShiftM;
import market.Mes.anneal.mapper.MesCrAnnealMMapper;
import market.Mes.anneal.vo.MesCrAnnealM;
import market.Mes.anneal.vo.MesJihuaZhi;
import market.Mes.util.DateUtil;
import market.Qms.qcm.vo.QcmJhyElements;
import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;

import org.apache.log4j.Logger;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

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

@RemoteService(path = "MesApiRollPdiPdoService")
public class MesApiRollPdiPdoImpl extends BaseServiceImpl implements MesApiRollPdiPdoService {

	
	public static String ROLLPDI_ORDER = PropertiesUtils.getPdioProperties().getProperty("ROLLPDI_ORDER");
	public static String ROLLPDI_PDI = PropertiesUtils.getPdioProperties().getProperty("ROLLPDI_PDI");
	public static String ROLLPDI_ORDERDELE = PropertiesUtils.getPdioProperties().getProperty("ROLLPDI_ORDERDELE");
	public static String ROLLPDI_NOORDER = PropertiesUtils.getPdioProperties().getProperty("ROLLPDI_NOORDER");
	public static String ROLLPDI_NOPDI = PropertiesUtils.getPdioProperties().getProperty("ROLLPDI_NOPDI");
	public static String ROLLPDI_L2ORDERDELE = PropertiesUtils.getPdioProperties().getProperty("ROLLPDI_L2ORDERDELE");
	public static String ROLLPDI_HUITUI = PropertiesUtils.getPdioProperties().getProperty("ROLLPDI_HUITUI");
	public static String ROLLPDI_MES = PropertiesUtils.getPdioProperties().getProperty("ROLLPDI_MES");
	public static String ROLLPDI_ROLLING = PropertiesUtils.getPdioProperties().getProperty("ROLLPDI_ROLLING");
	
	
	
	//获取日志记录器Logger，名字为本类类名
    private static Logger log = Logger.getLogger(MesApiRollPdiPdoImpl.class);
    
    
    
    /**
   	 * 轧机作业指示
   	 * @param oci
   	 * object:
	 * material_no:投料卷号
	 * materailcoilno：原始卷号
	 * steel_name:牌号
	 * order_no:订单号
	 * reciver_unit_name:客户名称
   	 * memo1:传机台代码
   	 * startTime:开始时间
   	 * endTime:结束时间
   	 * @return
   	 */
   	@SuppressWarnings("rawtypes")
	public ResultModel doQueryRollWeb(CommonPage<MesJihuaZhi> oci){
   		ResultModel rm=new ResultModel();
   		if(oci.getMemo1()==null || "".equals(oci.getMemo1())){
   			rm.setState("500");
   			rm.setMsgInfo("请输入机台代码");
   			return rm;
   		}
   		try{
   			List<HashMap> lpav=this.getMapper(IfRoll01L3PdiMapper.class).doQueryWeb(oci.getObject(),oci.getMemo1(),oci.getMemo2(),oci.getStartTime(),oci.getEndTime(),oci.getMemo3());
   			rm.setData(lpav);
   			rm.setState("200");
   		}catch(Exception ex){
   			ex.printStackTrace();
   			rm.setState("500");
   			rm.setMsgInfo("查询失败!"+ex.getMessage());
   		}
   		return rm;
   	}
   	
   	/**
   	 * 轧机二次切头尾情况
   	 * @param oci
   	 * object:
	 * material_no:投料卷号
	 * materailcoilno：原始卷号
	 * steel_name:牌号
	 * order_no:订单号
	 * reciver_unit_name:客户名称
   	 * memo1:传机台代码
   	 * startTime:开始时间
   	 * endTime:结束时间
   	 * @return
   	 */
//   	@SuppressWarnings("rawtypes")
//	public ResultModel doQueryRollWebErQie(CommonPage<MesJihuaZhi> oci){
//   		ResultModel rm=new ResultModel();
//   		if(oci.getMemo1()==null || "".equals(oci.getMemo1())){
//   			rm.setState("500");
//   			rm.setMsgInfo("请输入机台代码");
//   			return rm;
//   		}
//   		try{
//   			List<HashMap> lpav=this.getMapper(IfRoll01L3PdiMapper.class).doQueryWebErQie(oci.getObject(),oci.getMemo1(),oci.getMemo2(),oci.getStartTime(),oci.getEndTime(),oci.getMemo3());
//   			rm.setData(lpav);
//   			rm.setState("200");
//   		}catch(Exception ex){
//   			ex.printStackTrace();
//   			rm.setState("500");
//   			rm.setMsgInfo("查询失败!"+ex.getMessage());
//   		}
//   		return rm;
//   	}
    
    
    
    
	/**
	 *  1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2指示顺序请求电文时调用；																																							
		2)、	此接口参数为“L2指示顺序请求电文JSON对象”（电文编号：DR3E01）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L3AswOrder(IfRoll01L2AskOrd json){
		String v_message="";
		String v_mch_code="M0008";
		//  --(1)、函数参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_ask_ord 代替描述
		IfRoll01L2AskOrd v_rec_l2_ask_ord=json;
		if(json==null ){
			v_message="参数错误：二级接口-轧机_L2_指示顺序请求为空";
			//v_message="500";
			return v_message;
		}
		//  --(1、1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_ask_ord.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_ask_ord.setMsg_time(new Date());
		}
		//  --(1、2)、将对象，插入L2指示顺序请求表（单独的事务）
		try{
			this.getMapper(IfRoll01L2AskOrdMapper.class).insert(v_rec_l2_ask_ord);
		}catch(Exception e){
			e.printStackTrace();
		}
		//  --(2)、调用应答L2指示顺序请求函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3AswOrder_d(v_mch_code,v_rec_l2_ask_ord.getCoil_no(),
					strToLong(v_rec_l2_ask_ord.getNum_coil()),
					v_message);
			//this.getSqlSession("sqlSessionFactory").getConnection().
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_ask_ord.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String v_param="L2请求时间 MSG_TIME {"+mes_time+"} L2上次请求的最后一卷的卷号 COIL_NO {"+v_rec_l2_ask_ord.getCoil_no()+"}"
					+ "请求卷数 NUM_COIL {"+v_rec_l2_ask_ord.getNum_coil()+"}";
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L3AswOrder",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}
	
	/**
	 *  1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由接口 Roll01L3AswOrder 调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_ENTRY_COIL_NO（L2上次请求的最后一卷的卷号）、V_NUM_COIL（请求卷数）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param coil_no
	 * @param num_coil
	 * @param v_message
	 * @return
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L3AswOrder_d(String v_mch_code, String v_entry_coil_no,
			Long v_num_coil, String v_message) throws Exception{
		
		Integer v_cnt=null;
		Long v_count_pln=null;
		Long v_count_act=null;
		Long v_plan_seq=null;
		Long v_sr_seq=null;
		Integer v_success=null;
		List<HashMap> v_coil_no=new ArrayList<>();
		try{
			//  --(1)、验证传入参数的基本有效性
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//  --(1.3)、参数：请求卷数																																							
			//  --(1.3.1)、如果为空，或者 ≤ 0，则默认20																																							
			//  --(1.3.2)、如果 ＞ 200，则默认200																																							
			//  --(1.3.3)、否则直接使用																																							
			if(v_num_coil==null || v_num_coil<=0){
				v_count_pln=20l;
			}else if(v_num_coil>200){
				v_count_pln=200l;
			}else{
				v_count_pln=v_num_coil;
			}
			v_plan_seq=-1l;
			v_sr_seq=-1l;
			//  --(1.4)、参数：L2上次请求的最后一卷的卷号																																							
			//  --(1.4.1)、先获取此卷的 计划顺序号、计划内序号																																							
			v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount1(v_mch_code,v_entry_coil_no);
			if(v_cnt==1){
				//    --(1.4.2)、找到唯一的记录，则获取此卷的 计划顺序号、计划内序号
				PlnRollingPlan psp=this.getMapper(PlnRollingPlanMapper.class).doQuery1(v_mch_code,v_entry_coil_no);
				v_plan_seq=psp.getPlan_seq();
				v_sr_seq=psp.getRl_seq();
			}
			//  --(1.4.3)、未指定卷号，或指定卷号信息不存在，则找到已给L2指示顺序的最大 计划顺序号、计划内序号																																							
			if(v_plan_seq==-1 && v_sr_seq==-1){
				v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount2(v_mch_code,"");
				if(v_cnt>0){
					//  --(1.4.4)、先找到已给L2指示顺序的最大 计划顺序号																																							
					v_plan_seq=this.getMapper(PlnRollingPlanMapper.class).doCount3(v_mch_code,"");
					//  --(1.4.5)、再找此 计划顺序号下的最大 计划内序号																																							
					v_sr_seq=this.getMapper(PlnRollingPlanMapper.class).doCount4(v_mch_code,v_plan_seq);
				}
			}
			v_count_act=0l;// --实际卷数计数清零
			//  --(1.4.6)、循环 ≥ v_plan_seq 的计划主表，按 plan_seq 排序																																							
			List<PlnRollingPlan> cur_01_list=this.getMapper(PlnRollingPlanMapper.class).doQuery2(v_mch_code, v_plan_seq);
			for(PlnRollingPlan cur_01:cur_01_list){
				if(v_count_act>=v_count_pln){
					//continue;//--实际卷数，超出计划卷数，跳出循环
					break;//--实际卷数，超出计划卷数，跳出循环
				}
				//    --(1.4.7)、循环对应计划明细表，按 sr_seq 排序
				List<PlnRollingPlanDetail> cur_02_list=this.getMapper(PlnRollingPlanDetailMapper.class).findWithCondition(null, "rl_plan_no='"+cur_01.getRl_plan_no()+"'", "rl_seq", 0, 0);
				for(PlnRollingPlanDetail cur_02:cur_02_list){
					//      --(1.4.8)、从指定的钢卷往后开始找
					if((cur_01.getPlan_seq()==v_plan_seq && cur_02.getRl_seq()>v_sr_seq) ||
							cur_01.getPlan_seq()>v_plan_seq){
						if(v_count_act>=v_count_pln){
							//continue;//--实际卷数，超出计划卷数，跳出循环
							break;//--实际卷数，超出计划卷数，跳出循环
						}
						
						//  --(2.4)、验证当前还未生产交工
						MesRcmM mCross = new MesRcmM();
						mCross.setSchedule_no(cur_02.getRl_plan_no());
						mCross.setMaterial_no(cur_02.getObject_no());
						v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
						if(v_cnt>0){
							List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
						    MesRcmM v_rec_Roll_m =lmcam.get(0);
						    if("1".equals(v_rec_Roll_m.getHand_over_status())){
//						    	v_message="机台代码{"+v_mch_code+"} 入口卷号{"+cur_02.getObject_no()+"} 已生产交工";
//						    	return v_message;
						    	continue;
						    }
						}
						
						//--缓存钢卷号到集合队列中最后位置
						HashMap<String,String> hash=new HashMap();
						hash.put("entry_coil_no", cur_02.getObject_no());
						v_coil_no.add(hash);
						
 						//--计数器加1
						v_count_act=v_count_act+1;
					}
				}
			
			}
			//  --(2)、根据获取的可发送指示顺序的钢卷数，确定调用接口																																							
			//  --(2.1)、有可用的指示顺序																																							
			if(v_count_act>0){
				//--(2.1.1)、调用指示顺序接口
				try{
					v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3Order(v_coil_no,v_success,v_message);
				}catch(Exception e){
					e.printStackTrace();
					v_message=e.getMessage();
				}
				if(v_message==null){
					v_message="";
				}
				String v_success_str="";
				if(v_message.contains("_success:")){
					v_success_str=v_message.substring(v_message.length()-1);
					v_message=v_message.substring(0, v_message.lastIndexOf("_success"));
				}
				if("1".equals(v_success_str)){
					v_message="L2指示顺序请求应答成功！"+v_message;
				}else if("2".equals(v_success_str)){
					v_message="L2指示顺序请求应答部分成功！"+v_message;
				}else{
					v_message="L2指示顺序请求应答失败！"+v_message;
				}
			}else{
			   //  --(2.2)、无可用的指示顺序																																							
			   // --(2.2.1)、获取已下发指示顺序的钢卷数	
			   //select count(1) from pln_skinrolling_plan t1, pln_skinrolling_plan_detail t2 where t1.machine_code = 'M0008' and t1.sr_plan_no = t2.sr_plan_no and t2.send_flag is not null and t2.send_flag in ('1', '3') 	
			   v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount5(v_mch_code,"");
			   if(v_cnt>9999){
				   v_cnt=9999;//--电文字段长度所限
			   }
			   // --(2.2.2)、调用无指示顺序接口   --注意返回值
			   try{
					v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3NoOrder(v_entry_coil_no,v_cnt,v_success,v_message);
				}catch(Exception e){
					e.printStackTrace();
					v_message=e.getMessage();
			   }
			   if(v_message==null){
					v_message="";
			   }
			   String v_success_str="";
				if(v_message.contains("_success:")){
					v_success_str=v_message.substring(v_message.length()-1);
					v_message=v_message.substring(0, v_message.lastIndexOf("_success"));
				}
				if("1".equals(v_success_str)){
					v_message="L2无指示顺序请求应答成功！"+v_message;
				}else if("2".equals(v_success_str)){
					v_message="L2无指示顺序请求应答部分成功！"+v_message;
				}else{
					v_message="L2无指示顺序请求应答失败！"+v_message;
				}
			}
			
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L3AswOrder_d处理出错："+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L3AswOrder_d处理出错："+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}

	

	/**
	 * 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L3AswOrder_d 方法调用；																																							
		2)、	接口参数 IN：V_COIL_NO（卷号集合）																																							
		3)、	接口参数 OUT：V_SUCCESS（操作成功标志（1：成功、0：失败））、V_MESSAGE（操作结果信息）																																							
	 * @param v_coil_no
	 * @param v_success
	 * @param v_message
	 * @return
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value = "tm", rollbackFor = Exception.class)
	public String Roll01L3Order(List<HashMap>  v_coil_no, Integer v_success,
			String v_message) throws Exception{
		v_success=0;
		Integer v_num_coil;
		Integer v_flag=0;// --无接口调试时，设置1，直接跳过，否则设置为0
		try{
			//  --(2)、验证传入参数：																																							
			//  --(2.1)、未指定卷号集合																																							
			if(v_coil_no ==null || v_coil_no.size()<=0){
				v_message = "Roll01L3Order 未指定钢卷号！"+"_success:"+v_success;
				return v_message;
			}
			v_num_coil=v_coil_no.size();
			Integer youxiao_numcoil=v_coil_no.size();
			Integer ii=0;
			Integer jj=200-v_num_coil.intValue();
			for(ii=0;ii<jj;ii++){
				HashMap<String,String> hash=new HashMap();
				hash.put("entry_coil_no", new String());
				v_coil_no.add(hash);
			}
			
			//  --(3)、调用公司接口，将“指示顺序”电文发送给L2（电文格式见接口文档，获取接口执行成功状态：v_flag，错误信息：v_message）
			IfRollOrderView tlnov=new IfRollOrderView();
			tlnov.setNum_coil((v_num_coil==null?"":v_num_coil.longValue()+""));
			tlnov.setCoils(v_coil_no);
			
			JsonConfig jsonConfig=new JsonConfig();
			jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
			jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
			JSONObject jsonObject=JSONObject.fromObject(tlnov,jsonConfig);
			System.out.println(jsonObject.toString());
			try{
				log.debug("url:"+ROLLPDI_ORDER);
				String url = ROLLPDI_ORDER;
				String body = jsonObject.toString();
		        RestfulHttpClient.HttpResponse response = RestfulHttpClient.getClient(url)
		                .post()              //设置post请求
		                .addPostParam("body", "json")
		                .body(body)
		                .addHeader("Content-type", "application/json")   //添加header
		                //.addPathParam("id", "2")        //设置url路径参数
		                //.addQueryParam("test", "value") //设置url请求参数
		                .request();         //发起请求
		        System.out.println(response.getCode());     //响应状态码
		        System.out.println(response.getRequestUrl());//最终发起请求的地址
		        if(response.getCode() == 200){
		            //请求成功
		            //System.out.println(response.getContent());  //响应内容
		            log.debug("responseCONTENT:"+response.getContent());
		            if(response.getContent()!=null && (response.getContent().contains("vsuccess")|| response.getContent().contains("成功"))){//成功往L2的pdi表中插入数据
		            	v_flag=1;
		            	v_message="指示顺序电文下发成功！";
		            }else{
		            	if(response.getContent()!=null && response.getContent().length()>200){
		    				v_message="已下发指示顺序电文给L2，插入失败！【"+response.getContent().substring(0,200)+"】";
		    			}else{
		    				v_message="已下发指示顺序电文给L2，插入失败！【"+response.getContent()+"】";
		    			}
		            }
		        }else{
		        	v_message="下发指示顺序电文给L2失败！发送请求失败！";
		        }
			}catch(Exception e){
				e.printStackTrace();
				v_message="【通讯过程出错："+e.getMessage()+"】";
			}
			
			
			//  --(2.1)、电文发送失败（失败状态，根据接口提供定义确定）
			if(v_flag==0){
				v_message="Roll01L3Order 指示顺序电文发送失败！"+v_message+"_success:"+v_success;
				return v_message;
			}
			
			//  --(4)、插入接口记录表相关信息																																							
			//  --(4.1)、创建记录号																																							
			Long v_serial_no=this.getMapper(IfRoll01L3OrdMapper.class).doCount1();
			v_num_coil=v_coil_no.size();
			//  --(4.2)、开始事物：																																							
			for(int i=0;i<youxiao_numcoil;i++){
				if(v_coil_no!=null && v_coil_no.get(i)!=null && 
						v_coil_no.get(i).get("entry_coil_no")!=null && !"".equals(v_coil_no.get(i).get("entry_coil_no"))){
				//  --(4.3)、插入 IF_Roll01_L3_ORD_COIL 指示顺序钢卷记录			
					IfRoll01L3OrdCoil itloc=new IfRoll01L3OrdCoil();
					itloc.setSerial_no(v_serial_no);
					itloc.setSeq_no(longToString(Long.parseLong(i+"")));
					itloc.setEntry_coil_no(v_coil_no.get(i).get("entry_coil_no")+"");
					this.getMapper(IfRoll01L3OrdCoilMapper.class).insert(itloc);
					//   --(4.4)、更新 PLN_SKINROLLING_PLAN_DETAIL 指示顺序下发状态
					this.getMapper(PlnRollingPlanDetailMapper.class).doUpdate1(v_coil_no.get(i).get("entry_coil_no")+"","");
				}
				
			}
			//  --(4.5)、插入 IF_Roll01_L3_ORD 指示顺序主记录
			IfRoll01L3Ord itlo=new IfRoll01L3Ord();
			itlo.setSerial_no(v_serial_no);
			itlo.setSend_time(new Date());
			itlo.setSend_opr("L2Ask");
			itlo.setNum_coil(longToString(Long.parseLong(v_num_coil+"")));
			this.getMapper(IfRoll01L3OrdMapper.class).insert(itlo);
			//  --(5)、提交事务
			//  --唯一标示操作成功的地方																																							
			v_success = 1;																																							
			v_message = "Roll01L3Order 指示顺序电文发送成功！记录号{"+v_serial_no+"} 钢卷数{"+v_num_coil+"}"+"_success:"+v_success;
		}catch(Exception e){
			e.printStackTrace();
		    //--(6)、捕获未定义的异常，提示信息最多200字符																																							
		    //--(6.1)、电文发送成功（成功状态，根据接口提供定义确定）																																							
			if(v_flag==1){
				v_success=2;
				// --部分成功（电文已下发成功，但记录未写成功）
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3Order 指示顺序电文发送成功！"+e.getMessage().substring(0,200)+"_success:"+v_success;
				}else{
					v_message="Roll01L3Order 指示顺序电文发送成功！"+e.getMessage()+"_success:"+v_success;
				}
			}else{
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3Order 指示顺序电文发送失败！"+e.getMessage().substring(0,200)+"_success:"+v_success;
				}else{
					v_message="Roll01L3Order 指示顺序电文发送失败！"+e.getMessage()+"_success:"+v_success;
				}
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	/**
	    1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L3AswOrder_d 方法调用；																																							
		2)、	接口参数 IN：V_ENTRY_COIL_NO（已传送给L2的最后一个钢卷号）、V_NUM_COIL（已下发钢卷数）																																							
		3)、	接口参数 OUT：V_SUCCESS（操作成功标志（1：成功、0：失败））、V_MESSAGE（操作结果信息）																																							
	 * @param v_entry_coil_no
	 * @param v_cnt
	 * @param v_success
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value = "tm", rollbackFor = Exception.class)
	public String Roll01L3NoOrder(String v_entry_coil_no, Integer v_num_coil,
			Integer v_success, String v_message) throws Exception{
		//  --(1)、置输出参数：操作成功标志为0：失败
		v_success=0;
		Integer v_flag=0;// --无接口调试时，设置1，直接跳过，否则设置为0
		String v_coil_no;
		Integer v_count;//--已下发钢卷数
		try{
			//  --(2)、参数处理
			if(v_entry_coil_no ==null || "".equals(v_entry_coil_no)){
				v_coil_no = "00000000000000000000"; //--PS：20个0
			}else{
				v_coil_no=v_entry_coil_no;
			}
			if(v_num_coil==null || v_num_coil<0){
				v_count=0;
			}else if(v_num_coil>9999){
			    v_count = 9999;
			}else{
				 v_count = v_num_coil;
			}
			Roll0lL3NoView tlnov=new Roll0lL3NoView();
			tlnov.setEntry_coil_no(v_coil_no);
			tlnov.setNum_coils(v_count);
			//  --(3)、调用公司接口，将“无指示顺序”电文发送给L2（电文格式见接口文档，获取接口执行成功状态：v_flag，错误信息：v_message）																																							
			//  --(3.1)、电文参数，使用处理后的变量 v_coil_no，v_count																																							
			
			JsonConfig jsonConfig=new JsonConfig();
			jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
			jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
			JSONObject jsonObject=JSONObject.fromObject(tlnov,jsonConfig);
			System.out.println(jsonObject.toString());
			try{
				log.debug("url:"+ROLLPDI_NOORDER);
				String url = ROLLPDI_NOORDER;
				String body = jsonObject.toString();
		        RestfulHttpClient.HttpResponse response = RestfulHttpClient.getClient(url)
		                .post()              //设置post请求
		                .addPostParam("body", "json")
		                .body(body)
		                .addHeader("Content-type", "application/json")   //添加header
		                //.addPathParam("id", "2")        //设置url路径参数
		                //.addQueryParam("test", "value") //设置url请求参数
		                .request();         //发起请求
		        System.out.println(response.getCode());     //响应状态码
		        System.out.println(response.getRequestUrl());//最终发起请求的地址
		        if(response.getCode() == 200){
		            //请求成功
		            //System.out.println(response.getContent());  //响应内容
		            log.debug("responseCONTENT:"+response.getContent());
		            if(response.getContent()!=null && (response.getContent().contains("vsuccess")|| response.getContent().contains("成功"))){//成功往L2的pdi表中插入数据
		            	v_flag=1;
		            	v_message="无指示顺序电文下发成功！";
		            }else{
		            	if(response.getContent()!=null && response.getContent().length()>200){
		    				v_message="已下发无指示顺序电文给L2，插入失败！【"+response.getContent().substring(0,200)+"】";
		    			}else{
		    				v_message="已下发无指示顺序电文给L2，插入失败！【"+response.getContent()+"】";
		    			}
		            }
		        }else{
		        	v_message="下发无指示顺序电文给L2失败！发送请求失败！";
		        }
			}catch(Exception e){
				e.printStackTrace();
				v_message="【通讯过程出错："+e.getMessage()+"】";
			}
			
			
			
			//  --(3.2)、电文发送失败（失败状态，根据接口提供定义确定）																																							
			if(v_flag == 0){																																							
			    v_message = "Roll01L3NoOrder 无指示顺序电文发送失败！"+v_message+"_success:"+v_success;																																			
			    return v_message;																																							
			}																																						
			//  --(4)、插入接口记录表相关信息		
			IfRoll01L3NoneOrd itlno=new IfRoll01L3NoneOrd();
			itlno.setSend_time(new Date());
			itlno.setSend_opr("L2Ask");
			itlno.setEntry_coil_no(v_coil_no);
			itlno.setNum_coils(longToString(Long.parseLong(v_count+"")));
			this.getMapper(IfRoll01L3NoneOrdMapper.class).insert(itlno);
			//  --(5)、提交事务
			//  --唯一标示操作成功的地方																																							
			v_success = 1;																																							
			v_message = "Roll01L3NoOrder 无指示顺序电文发送成功！ENTRY_COIL_NO {"+v_coil_no+"} NUM_COILS {"+v_count+"}"+"_success:"+v_success;		
		}catch(Exception e){
			e.printStackTrace();
		    //--(6)、捕获未定义的异常，提示信息最多200字符																																							
		    //--(6.1)、电文发送成功（成功状态，根据接口提供定义确定）																																							
			if(v_flag==1){
				v_success=2;
				// --部分成功（电文已下发成功，但记录未写成功）
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3NoOrder 无指示顺序电文发送成功！"+e.getMessage().substring(0,200)+"_success:"+v_success;
				}else{
					v_message="Roll01L3NoOrder 无指示顺序电文发送成功！"+e.getMessage()+"_success:"+v_success;
				}
			}else{
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3NoOrder 无指示顺序电文发送失败！"+e.getMessage().substring(0,200)+"_success:"+v_success;
				}else{
					v_message="Roll01L3NoOrder 无指示顺序电文发送失败！"+e.getMessage()+"_success:"+v_success;
				}
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2 PDI数据请求电文时调用；																																							
		2)、	此接口参数为“L2 PDI数据请求电文JSON对象”（电文编号：DR3E02）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L3AswPdi(IfRoll01L2AskPdi json){
		String v_message="";
		String v_mch_code="M0008";
		//  --(1)、参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_ask_pdi 代替描述
		IfRoll01L2AskPdi v_rec_l2_ask_pdi=json;
		if(json==null ){
			v_message="参数错误：二级接口-轧机_L2_PDI数据请求为空";
			return v_message;
		}
		//  --(1、1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_ask_pdi.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_ask_pdi.setMsg_time(new Date());
		}
		//  --(1.2)、将对象，插入L2 PDI数据请求表（单独的事务）
		try{
			this.getMapper(IfRoll01L2AskPdiMapper.class).insert(v_rec_l2_ask_pdi);
		}catch(Exception e){
			e.printStackTrace();
		}
		//  --(2)、调用应答L2 PDI数据请求函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3AswPdi_d(v_mch_code,v_rec_l2_ask_pdi.getEntry_coil_no(),
					v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_ask_pdi.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String v_param="L2请求时间 MSG_TIME {"+mes_time+"} 入口卷号 ENTRY_COIL_NO {"+v_rec_l2_ask_pdi.getEntry_coil_no()+"}";
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L3AswPdi",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}
	
	
	/**
	 *	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L3AswPdi 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_ENTRY_COIL_NO（入口卷号）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param entry_coil_no
	 * @param v_message
	 * @return
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L3AswPdi_d(String v_mch_code, String v_entry_coil_no,
			String v_message) throws Exception{
		
		Integer v_cnt=null;
		String v_msg="";
		String v_entry_location=null;
		String v_steel=null;
		Integer v_success=null;
		PlnRollingPlanDetail v_rec_pln_d=new PlnRollingPlanDetail();
		YdmProductDetail v_rec_ydm_d=new YdmProductDetail();
		IfRoll01L3Pdi  v_rec_pdi=new IfRoll01L3Pdi();
		try{
			//  --(1.1)、验证传入参数的基本有效性
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			Integer v_flag=1;//--变量默认为1，认为有PDI数据
			if(v_entry_coil_no==null || "".equals(v_entry_coil_no)){
				v_msg="入口卷号{"+v_entry_coil_no+"} 未指定入口卷号！";
				v_flag=0;//--无PDI数据
			}
			//  --(2)、验证入口卷对应的作业计划信息存在
			if(v_flag==1){
				v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount1(v_mch_code,v_entry_coil_no);
				if(v_cnt<=0){
					v_msg="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 找不到作业计划信息！";
					v_flag=0;//--无PDI数据    
				}else if(v_cnt>1){
					v_msg="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"}存在2条或以上的作业计划信息！";
					v_flag=0;//--无PDI数据    
				}else{
					List<PlnRollingPlanDetail> v_rec_pln_d_list=this.getMapper(PlnRollingPlanDetailMapper.class).doQuery3(v_mch_code, v_entry_coil_no);
					v_rec_pln_d=v_rec_pln_d_list.get(0);
				}
			}
			// --(3)、验证入口卷对应的库存明细存在
			List<YdmProductDetail> v_rec_ydm_d_list=new ArrayList<>();
			if(v_flag==1){
				v_rec_ydm_d_list = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "coilno='"+v_entry_coil_no+"'", null, 0, 0);
				if(v_rec_ydm_d_list==null || v_rec_ydm_d_list.size()<=0){
					v_msg="入口卷号{"+v_entry_coil_no+"}库存明细记录不存在！";
					v_flag=0;//--无PDI数据    
				}
				//2019-03-07
				v_rec_ydm_d=v_rec_ydm_d_list.get(0);
			}
			
			//  --(2.4)、验证当前还未生产交工
			MesRcmM mCross = new MesRcmM();
			mCross.setSchedule_no(v_rec_pln_d.getRl_plan_no());
			mCross.setMaterial_no(v_entry_coil_no);
			v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
			if(v_cnt>0){
				List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
			    MesRcmM v_rec_Roll_m =lmcam.get(0);
			    if("1".equals(v_rec_Roll_m.getHand_over_status())){
			    	v_msg="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 已生产交工，不能重复下发PDI！";
			    	//return v_message;
			    	v_flag=0;//--无PDI数据    
			    }
			}
			
			List<PlnMaterielDetail> v_rec_mtr_in_list=null;
			//  --(4)、验证入口卷对应的虚拟物料信息存在	
			if(v_flag==1){
				v_rec_mtr_in_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
						"object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"' and object_no='"+v_rec_pln_d.getObject_no()+"'", null, 0, 0);
				if(v_rec_mtr_in_list==null || v_rec_mtr_in_list.size()<=0){
					v_msg="入口卷号{"+v_entry_coil_no+"} 虚拟物料信息不存在！";
					v_flag=0;//--无PDI数据    
				}
			}	
			
			//出口目标
			List<PlnMaterielDetail> v_rec_mtr_out_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"mat_object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_out_list==null || v_rec_mtr_out_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_entry_coil_no+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+" 出口卷虚拟物料信息不存在！";
				return v_message;
			}
			PlnMaterielDetail v_rec_mtr_out=v_rec_mtr_out_list.get(0);
			
			
			//  --(5)、获取其它相关信息，注意忽略错误
			if(v_flag==1){
				//    --(5.1)、获取牌号/钢种名称
				List<ComBaseSteel> lcbs = this.getMapper(ComBaseSteelMapper.class).findWithCondition(null, "steel_code='"+v_rec_ydm_d.getSteelcode()+"'", null, 0, 0);
				if(lcbs==null || lcbs.size()<=0){
					v_steel=v_rec_ydm_d.getSteelcode();
				}else{
					if(lcbs.get(0).getSteel_name()==null){
						v_steel=lcbs.get(0).getSteel_code();
					}else{
						v_steel=lcbs.get(0).getSteel_name();
					}
				}
				//    --(5.2)、获取入口卷库位
				v_entry_location=this.getMapper(MesCrAnnealMMapper.class).doQueryLocation(v_entry_coil_no);
				if(v_entry_location==null){
					v_entry_location="";
				}
			}
			//  --(6)、根据 v_flag 标志，确定调用接口																																							
			//  --(6.1)、v_flag = 1，有可用的PDI数据																																							
			if(v_flag==1){
				//    --(6.1.0)、PDI数据属性赋值（注意：记录号、下发时间、下发人，到调用接函数内才赋值）
			    v_rec_pdi.setEntry_coil_no        ( v_entry_coil_no);// --入口卷号																																							
			    v_rec_pdi.setExit_coil_no         ( v_entry_coil_no);// --出口卷号																																							
			    v_rec_pdi.setEntry_coil_source    ( "1");// --入口卷来源（0：自产、1：外购）																																							
			    v_rec_pdi.setPlan_no              ( v_rec_pln_d.getRl_plan_no());// --计划号	
			    if(v_rec_mtr_in_list!=null &&v_rec_mtr_in_list.size()>0){
			    	 //List<PlnProdorder> v_rec_prod = this.getMapper(PlnProdorderMapper.class).findWithCondition(null, "prod_order_no='"+v_rec_mtr_in_list.get(0).getProd_order_no()+"'", null, 0, 0);
			    	 //v_rec_pdi.setCustomer(v_rec_prod.get(0).getCustomer_name());
			    	 //v_rec_pdi.setCustomer("下游客户");
			    }
				v_rec_pdi.setSupplier(null);//原料供应商
				if(v_rec_ydm_d.getLength()!=null){
					  Double len=v_rec_ydm_d.getLength()/1000;
					  v_rec_pdi.setEntry_length(longToString(len.longValue()));//来料长度
				  }
				v_rec_pdi.setEntry_crown(null);//来料凸度
			    
			    
			    if(v_rec_ydm_d.getThick()!=null){
			    	Double thick_um=v_rec_ydm_d.getThick()*1000;
			    	v_rec_pdi.setEntry_thichness(longToString(thick_um.longValue()));// --入口热卷厚度（um）	//	1mm（毫米）=1000um（微米) 
			    }
			    //出口厚度
			    v_rec_pdi.setExit_thickness(v_rec_mtr_out.getThick()==null?"":(v_rec_mtr_out.getThick()+""));
			    
			    if(v_rec_ydm_d.getWidth()!=null){
			    	Double width_um=v_rec_ydm_d.getWidth();
			    	v_rec_pdi.setEntry_width(longToString(width_um.longValue()));// --入口热卷宽度（mm）	//1mm（毫米）=1000um（微米)
			    }
			    if(v_rec_ydm_d.getFactweight()!=null){
			    	v_rec_pdi.setEntry_weight(longToString(v_rec_ydm_d.getFactweight().longValue()));// --入口热卷重量（kg）  ？？
			    }
			    if(v_rec_ydm_d.getDiameter_inn()!=null){
			    	v_rec_pdi.setInner_diameter(longToString(v_rec_ydm_d.getDiameter_inn().longValue()));// --入口热卷内径（mm）
			    }
			    if(v_rec_ydm_d.getDiameter_out()!=null){
			    	v_rec_pdi.setOuter_diameter(longToString(v_rec_ydm_d.getDiameter_out().longValue()));// --入口热卷外径（mm）		
			    }
			    v_rec_pdi.setHarderness_annealing ( null);// --退火后硬度																																							
			    v_rec_pdi.setTemp_annealing       ( null);// --退火温度（℃）																																							
			    v_rec_pdi.setSpm_mode             ( "1");// --平整模式（0：平整、1：轧制），需要生产或质量提供接口																																							
			    v_rec_pdi.setSpm_elong            ( null);// --平整伸长率（0.01%，e.g. 255 => 2.55 %  ，平整模式），需要生产或质量提供接口																																							
			    v_rec_pdi.setReduce               ( null);// --压下率（%），需要生产或质量提供接口																																							
			    v_rec_pdi.setSleeve               ("0");// --套筒（0：无、1：有），需要生产或质量提供接口																																							
			    v_rec_pdi.setOuter_dia_sleeve     ( null);// --出口套筒外径（520~600），需要生产或质量提供接口																																							
			    v_rec_pdi.setWeight_sleeve        ( null);// --套筒重量（10^-2kg），需要生产或质量提供接口	
			    
			    v_rec_pdi.setGb_steel_grade       ( v_steel);// --国标钢种																																							
			    v_rec_pdi.setSteel_grade          ( v_steel);// --钢种																																							
			    v_rec_pdi.setPreced_process_code  ( "");// --上道工序代码																																							
			    v_rec_pdi.setNext_process_code    ( "");// --后道工序代码																																							
			    v_rec_pdi.setComment              ( "");// --备注信息																																							
			    //v_rec_pdi.setExit_yard_location   ( "test_loc");// --出口库位																																							
			    //v_rec_pdi.setEntry_yard_location  ( v_entry_location);// --入口库位																																							
			    v_rec_pdi.setReserve1              ( v_rec_ydm_d.getMaterailcoilno());// --预留	
			    
			    try{
				  ResultModel getElementsInfo = this.getBean(QmsApiServiceImpl.class).GetElementsInfo(v_rec_ydm_d.getMaterailcoilno());
				  if(getElementsInfo!=null && getElementsInfo.getData()!=null){
					  List<QcmJhyElements> qje=(List)getElementsInfo.getData();
					  if(qje!=null && qje.size()>0){
						  for(QcmJhyElements qjed:qje){
							  //v_rec_pdi.setAlloy_components_avai(alloy_components_avai);
							  if("Als".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_als(qjed.getChem_value());
							  }else if("Alt".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_alt(qjed.getChem_value());
							  }else if("As".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_as(qjed.getChem_value());
							  }else if("B".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_b(qjed.getChem_value());
							  }else if("Bi".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_bi(qjed.getChem_value());
							  }else if("C".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_c(qjed.getChem_value());
							  }else if("Ca".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_ca(qjed.getChem_value());
							  }else if("Cd".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_cd(qjed.getChem_value());
							  }else if("Cr".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_cr(qjed.getChem_value());
							  }else if("Cu".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_cu(qjed.getChem_value());
							  }else if("Fe".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_fe(qjed.getChem_value());
							  }else if("La".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_la(qjed.getChem_value());
							  }else if("Mn".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_mn(qjed.getChem_value());
							  }else if("Mo".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_mo(qjed.getChem_value());
							  }else if("N".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_n(qjed.getChem_value());
							  }else if("Nb".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_nb(qjed.getChem_value());
							  }else if("Ni".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_ni(qjed.getChem_value());
							  }else if("P".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_p(qjed.getChem_value());
							  }else if("Pb".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_pb(qjed.getChem_value());
							  }else if("S".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_s(qjed.getChem_value());
							  }else if("Sb".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_sb(qjed.getChem_value());
							  }else if("Se".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_se(qjed.getChem_value());
							  }else if("Si".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_si(qjed.getChem_value());
							  }else if("Sn".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_sn(qjed.getChem_value());
							  }else if("Ti".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_ti(qjed.getChem_value());
							  }else if("V".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_v(qjed.getChem_value());
							  }else if("W".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_w(qjed.getChem_value());
							  }else if("Zn".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_zn(qjed.getChem_value());
							  }else if("Zr".equals(qjed.getChem_name())){
								  v_rec_pdi.setCa_zr(qjed.getChem_value());
							  }
							  
						  }
					  }
				  }
				  }catch(Exception e){
					  e.printStackTrace();
				  }
			    
			    
			    //测试内容：
//			    v_rec_pdi.setCa_c("0.45601");
//			    v_rec_pdi.setCa_mn("0.002");
			    
			    
			    // --(6.1.1)、调用PDI数据接口
			    try{
			    	String vOprName = (String) this.getSession().getAttribute(HomeService.SESSION_USER_NAME);
					if(vOprName==null){
						vOprName="L2Ask";
					}
					v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3Pdi(v_rec_pdi,vOprName,v_success,
							v_message);
				}catch(Exception e){
					e.printStackTrace();
					v_message=e.getMessage();
				}
				if(v_message==null){
					v_message="";
				}
				String v_success_str="";
				if(v_message.contains("_success:")){
					v_success_str=v_message.substring(v_message.length()-1);
					v_message=v_message.substring(0, v_message.lastIndexOf("_success"));
				}
				if("1".equals(v_success_str)){
					//v_message="L2 PDI数据请求应答成功！"+v_message;
				}else if("2".equals(v_success_str)){
					v_message="L2 PDI数据请求应答部分成功！"+v_message;
				}else{
					//v_message="L2 PDI数据请求应答失败！"+v_message;
				}
			}else{
				//--(6.2)、调用无PDI数据接口
				try{
					v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3NoPdi(v_entry_coil_no,"L2Ask",v_success,
							v_message);
				}catch(Exception e){
					e.printStackTrace();
					v_message=e.getMessage();
				}
				if(v_message==null){
					v_message="";
				}
				String v_success_str="";
				if(v_message.contains("_success:")){
					v_success_str=v_message.substring(v_message.length()-1);
					v_message=v_message.substring(0, v_message.lastIndexOf("_success"));
				}
				if("1".equals(v_success_str)){
					v_message="L2  无PDI数据请求应答成功！"+v_msg+v_message;
				}else if("2".equals(v_success_str)){
					v_message="L2  无PDI数据请求应答部分成功！"+v_msg+v_message;
				}else{
					v_message="L2  无PDI数据请求应答失败！"+v_msg+v_message;
				}
			}
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L3AswPdi_d处理出错："+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L3AswPdi_d处理出错："+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}

	/**
		1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L3AswPdi_d 或 Roll01L3SendPdi_d 方法调用；																																							
		2)、	接口参数 IN：V_REC_PDI（PDI数据对象）、V_OPR_NAME（操作人）																																							
		3)、	接口参数 OUT：V_SUCCESS（操作成功标志（1：成功、0：失败））、V_MESSAGE（操作结果信息）																																							
	 * @param v_rec_pdi
	 * @param string
	 * @param v_success
	 * @param v_message
	 * @return
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value="tm", rollbackFor=Exception.class)
	public String Roll01L3Pdi(IfRoll01L3Pdi v_rec_pdi, String v_opr_name,
			Integer v_success, String v_message) throws Exception{
		v_success=0;
		Integer v_flag=0;// --无接口调试时，设置1，直接跳过，否则设置为0  
		
		try{
			//  --(2)、调用公司接口，将“PDI数据”电文发送给L2（电文格式见接口文档，获取接口执行成功状态：v_flag，错误信息：v_message）
			
			
			JsonConfig jsonConfig=new JsonConfig();
			jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
			jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
			JSONObject jsonObject=JSONObject.fromObject(v_rec_pdi,jsonConfig);
			System.out.println(jsonObject.toString());
			try{
				log.debug("url:"+ROLLPDI_PDI);
				String url = ROLLPDI_PDI;
				String body = jsonObject.toString();
		        RestfulHttpClient.HttpResponse response = RestfulHttpClient.getClient(url)
		                .post()              //设置post请求
		                .addPostParam("body", "json")
		                .body(body)
		                .addHeader("Content-type", "application/json")   //添加header
		                //.addPathParam("id", "2")        //设置url路径参数
		                //.addQueryParam("test", "value") //设置url请求参数
		                .request();         //发起请求
		        System.out.println(response.getCode());     //响应状态码
		        System.out.println(response.getRequestUrl());//最终发起请求的地址
		        if(response.getCode() == 200){
		            //请求成功
		            //System.out.println(response.getContent());  //响应内容
		            log.debug("responseCONTENT:"+response.getContent());
		            if(response.getContent()!=null && (response.getContent().contains("vsuccess")|| response.getContent().contains("成功"))){//成功往L2的pdi表中插入数据
		            	v_flag=1;
		            	v_message="PDI下发成功！";
		            }else{
		            	if(response.getContent()!=null && response.getContent().length()>200){
		    				v_message="已下发PDI给L2，插入失败！【"+response.getContent().substring(0,200)+"】";
		    			}else{
		    				v_message="已下发PDI给L2，插入失败！【"+response.getContent()+"】";
		    			}
		            }
		        }else{
		        	v_message="下发PDI给L2失败！发送请求失败！";
		        }
			}catch(Exception e){
				e.printStackTrace();
				v_message="【通讯过程出错："+e.getMessage()+"】";
			}
			
			
			//  --(2.1)、电文发送失败（失败状态，根据接口提供定义确定）
			if(v_flag==0){
				v_message="Roll01L3Pdi PDI数据电文发送失败！"+v_message+"_success:"+v_success;
				return v_message;
			}
			//  --(3)、插入接口记录表相关信息																																							
			//  --(3.1)、创建记录号																																							
			Long v_serial_no=this.getMapper(IfRoll01L3PdiMapper.class).doCount1();
			
			//  --(3.2)、开始事物：																																							
			//  --(3.2.1)、插入 IF_Roll01_L3_PDI PDI数据记录																																							
			v_rec_pdi.setSerial_no(v_serial_no);
			v_rec_pdi.setSend_time(new Date());
			v_rec_pdi.setSend_opr(v_opr_name);
			this.getMapper(IfRoll01L3PdiMapper.class).insert(v_rec_pdi);
			//  --(3.2.2)、更新 PLN_SKINROLLING_PLAN_DETAIL PDI数据下发状态
			if(v_opr_name==null){
				v_opr_name="";
			}
			this.getMapper(PlnRollingPlanDetailMapper.class).doUpdate2(v_opr_name,v_rec_pdi.getPlan_no(), v_rec_pdi.getEntry_coil_no());
			//  --(4)、提交事务
			//  --唯一标示操作成功的地方																																							
			v_success = 1;																																							
			v_message = "Roll01L3Pdi PDI数据电文发送成功！记录号{"+v_serial_no+"} 计划号{"+v_rec_pdi.getPlan_no()+"} 入口卷号{"+v_rec_pdi.getEntry_coil_no()+"}"+"_success:"+v_success;
		}catch(Exception e){
			e.printStackTrace();
		    //--(6)、捕获未定义的异常，提示信息最多200字符																																							
		    //--(6.1)、电文发送成功（成功状态，根据接口提供定义确定）																																							
			if(v_flag==1){
				v_success=2;
				// --部分成功（电文已下发成功，但记录未写成功）
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3Pdi PDI数据电文发送成功！"+e.getMessage().substring(0,200)+"_success:"+v_success;
				}else{
					v_message="Roll01L3Pdi PDI数据电文发送成功！"+e.getMessage()+"_success:"+v_success;
				}
			}else{
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3Pdi PDI数据电文发送失败！"+e.getMessage().substring(0,200)+"_success:"+v_success;
				}else{
					v_message="Roll01L3Pdi PDI数据电文发送失败！"+e.getMessage()+"_success:"+v_success;
				}
			}
			throw new Exception(v_message);
		}
		return v_message;
	}

	/**
	 1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L3AswPdi_d 方法调用；																																							
	 2)、	接口参数 IN：V_ENTRY_COIL_NO（L2请求的钢卷号）、V_OPR_NAME（操作人）																																							
	 3)、	接口参数 OUT：V_SUCCESS（操作成功标志（1：成功、0：失败））、V_MESSAGE（操作结果信息）																																							
	 * @param v_entry_coil_no
	 * @param string
	 * @param v_success
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value="tm", rollbackFor=Exception.class)
	public String Roll01L3NoPdi(String v_entry_coil_no, String v_opr_name,
			Integer v_success, String v_message) throws Exception{
		//  --(1)、置输出参数：操作成功标志为0：失败
		v_success=0;
		Integer v_flag=0;// --无接口调试时，设置1，直接跳过，否则设置为0
		String v_coil_no;
		try{
			//  --(2)、参数处理
			if(v_entry_coil_no ==null || "".equals(v_entry_coil_no)){
				v_coil_no = "00000000000000000000"; //--PS：20个0
			}else{
				v_coil_no=v_entry_coil_no;
			}
			Roll0lL3NoView ilnv=new Roll0lL3NoView();
			ilnv.setEntry_coil_no(v_coil_no);
			//ilnv.setNum_coil(v_num_coil);
			//  --(3)、调用公司接口，将“无PDI数据”电文发送给L2（电文格式见接口文档，获取接口执行成功状态：v_flag，错误信息：v_message）																																							
			//  --(3.1)、电文参数，使用处理后的变量 v_coil_no																																							
			//  --......																																							
			
			JsonConfig jsonConfig=new JsonConfig();
			jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
			jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
			JSONObject jsonObject=JSONObject.fromObject(ilnv,jsonConfig);
			System.out.println(jsonObject.toString());
			try{
				log.debug("url:"+ROLLPDI_NOPDI);
				String url = ROLLPDI_NOPDI;
				String body = jsonObject.toString();
		        RestfulHttpClient.HttpResponse response = RestfulHttpClient.getClient(url)
		                .post()              //设置post请求
		                .addPostParam("body", "json")
		                .body(body)
		                .addHeader("Content-type", "application/json")   //添加header
		                //.addPathParam("id", "2")        //设置url路径参数
		                //.addQueryParam("test", "value") //设置url请求参数
		                .request();         //发起请求
		        System.out.println(response.getCode());     //响应状态码
		        System.out.println(response.getRequestUrl());//最终发起请求的地址
		        if(response.getCode() == 200){
		            //请求成功
		            //System.out.println(response.getContent());  //响应内容
		            log.debug("responseCONTENT:"+response.getContent());
		            if(response.getContent()!=null && (response.getContent().contains("vsuccess")|| response.getContent().contains("成功"))){//成功往L2的pdi表中插入数据
		            	v_flag=1;
		            	v_message="无PDI下发成功！";
		            }else{
		            	if(response.getContent()!=null && response.getContent().length()>200){
		    				v_message="已下发无PDI给L2，插入失败！【"+response.getContent().substring(0,200)+"】";
		    			}else{
		    				v_message="已下发无PDI给L2，插入失败！【"+response.getContent()+"】";
		    			}
		            }
		        }else{
		        	v_message="下发无PDI给L2失败！发送请求失败！";
		        }
			}catch(Exception e){
				e.printStackTrace();
				v_message="【通讯过程出错："+e.getMessage()+"】";
			}
			
			
			
			//  --(3.2)、电文发送失败（失败状态，根据接口提供定义确定）																																							
			if(v_flag == 0){																																							
			    v_message = "Roll01L3NoPdi 无PDI数据电文发送失败！"+v_message+"_success:"+v_success;																																			
			    return v_message;																																							
			}																																						
			// --(4)、插入接口记录表相关信息		
			IfRoll01L3NonePdi itlno=new IfRoll01L3NonePdi();
			itlno.setSend_time(new Date());
			itlno.setSend_opr(v_opr_name);
			itlno.setEntry_coil_no(v_coil_no);
			this.getMapper(IfRoll01L3NonePdiMapper.class).insert(itlno);
			//  --(5)、提交事务
			//  --唯一标示操作成功的地方																																							
			v_success = 1;																																							
			v_message = "Roll01L3NoPdi 无PDI数据电文发送成功！ENTRY_COIL_NO {"+v_coil_no+"}"+"_success:"+v_success;		
		}catch(Exception e){
			e.printStackTrace();
		    //--(6)、捕获未定义的异常，提示信息最多200字符																																							
		    //--(6.1)、电文发送成功（成功状态，根据接口提供定义确定）																																							
			if(v_flag==1){
				v_success=2;
				// --部分成功（电文已下发成功，但记录未写成功）
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3NoPdi 无PDI数据电文发送成功！"+e.getMessage().substring(0,200)+"_success:"+v_success;
				}else{
					v_message="Roll01L3NoPdi 无PDI数据电文发送成功！"+e.getMessage()+"_success:"+v_success;
				}
			}else{
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3NoPdi 无PDI数据电文发送失败！"+e.getMessage().substring(0,200)+"_success:"+v_success;
				}else{
					v_message="Roll01L3NoPdi 无PDI数据电文发送失败！"+e.getMessage()+"_success:"+v_success;
				}
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2指示删除电文时调用；																																							
		2)、	此接口参数为“L2指示删除电文JSON对象”（电文编号：DR3E03）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2Revoke(IfRoll01L2Revoke json){
		String v_message="";
		String v_mch_code="M0008";
		//  --(1)、参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_rvk 代替描述
		IfRoll01L2Revoke v_rec_l2_rvk=json;
		if(json==null){
			v_message="二级接口-轧机_L2_指示删除为空";
			return v_message;
		}
		//  --(1.1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_rvk.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_rvk.setMsg_time(new Date());
		}
		//  --(1.2)、将对象，插入L2指示删除表（单独的事务）
		try{
			this.getMapper(IfRoll01L2RevokeMapper.class).insert(v_rec_l2_rvk);
		}catch(Exception e){
			e.printStackTrace();
		}
		//  --(2)、调用L2指示删除处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2Revoke_d(v_mch_code,v_rec_l2_rvk.getEntry_coil_no(),
					v_rec_l2_rvk.getOperator(),v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_rvk.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String v_param="消息时间 MSG_TIME {"+mes_time+"} 入口卷号 ENTRY_COIL_NO {"+v_rec_l2_rvk.getEntry_coil_no()+"} "
			  		+ "删除责任者 OPERATOR {"+v_rec_l2_rvk.getOperator()+"} 删除原因代码 REASON_CODE {"+v_rec_l2_rvk.getReason_code()+"}";																																							
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2Revoke",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}

	
	/**
	 *	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L3AswPdi 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_ENTRY_COIL_NO（入口卷号）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param entry_coil_no
	 * @param v_message
	 * @return
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2Revoke_d(String v_mch_code, String v_entry_coil_no,
			String v_operator, String v_message) throws Exception{
		
		IfRoll01L3AnswerRevoke v_rec_l3_asw_rvk=new IfRoll01L3AnswerRevoke();
		Integer v_success=null;
		try{
			//  --(1)、调用 L2指示删除 处理函数
			try{
				v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2Revoke_d_d(v_mch_code,v_entry_coil_no,
						v_operator,v_success,v_message);
			}catch(Exception e){
				e.printStackTrace();
				v_message=e.getMessage();
			}
			//  --(1.1)、构造 L3应答L2指示数据删除 电文																																							
			//  --(1.1.1)、L3处理L2指示删除电文成功（1：成功）																																							
			if(v_message==null){
				v_message="";
			}
			String v_success_str="";
			//对v_message和v_success进行处理
			if(v_message.contains("_success:")){
				v_success_str=v_message.substring(v_message.length()-1);
				//v_success= Integer.parseInt(v_success_str);
				v_message=v_message.substring(0, v_message.lastIndexOf("_success"));
			}
			if("1".equals(v_success_str)){
			    v_rec_l3_asw_rvk.setResult("0");// --处理结果（0：成功、1：错误）
			}else{
				v_rec_l3_asw_rvk.setResult("1");//--处理标志（0：成功、1：不成功）
			}
			v_rec_l3_asw_rvk.setEntry_coil_no(v_entry_coil_no);//--入口钢卷号
			v_rec_l3_asw_rvk.setSend_time(new Date());
			v_rec_l3_asw_rvk.setSend_opr("L3");//--下发人
			//  --(2)、调用 L3应答L2指示数据删除 处理函数
			String v_message2="";
			try{
				v_message2=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3AswRevoke(v_rec_l3_asw_rvk,v_message2);
			}catch(Exception e){
				e.printStackTrace();
				v_message2=e.getMessage();
			}
			String send_time=DateUtil.formatDate(v_rec_l3_asw_rvk.getSend_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(4)、拼接返回字符串
			String v_param= "下发时间 SEND_TIME {"+send_time+"} 下发人 SEND_OPR {"+v_rec_l3_asw_rvk.getSend_opr()+"} "
					+ "入口卷号 ENTRY_COIL_NO {"+v_rec_l3_asw_rvk.getEntry_coil_no()+"} 处理结果（0：成功、1：错误） RESULT {"+v_rec_l3_asw_rvk.getResult()+"}";
			//  --(5)、写接口日志：与业务处理分开，单独的事务
			try{
				this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L3AswRevoke",v_param,v_message2);
			}catch(Exception e){
				e.printStackTrace();
			}
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2Revoke_d处理出错："+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2Revoke_d处理出错："+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}

	/**
	 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Revoke_d 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_ENTRY_COIL_NO（入口卷号）、V_OPERATOR（删除操作人）																																							
		3)、	接口参数 OUT：V_SUCCESS（操作成功标志（1：成功、0：失败））、V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_entry_coil_no
	 * @param v_operator
	 * @param v_success
	 * @param v_message
	 * @return
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value="tm", rollbackFor=Exception.class)
	public String Roll01L2Revoke_d_d(String v_mch_code, String v_entry_coil_no,
			String v_operator, Integer v_success, String v_message) throws Exception{
		//  --(0)、置输出参数：操作成功标志为0：失败
		v_success=0;
		Integer v_cnt=null;
		PlnRollingPlanDetail v_rec_pln_d=new PlnRollingPlanDetail();
		try{
			//  --(1.1)、验证机台代码不为空
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message+"_success:"+v_success;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message+"_success:"+v_success;
			}
			//  --(1.3)、验证入口卷号不为空
			if(v_entry_coil_no==null || "".equals(v_entry_coil_no)){
				v_message="入口卷号{"+v_entry_coil_no+"} 未指定入口卷号！";
				return v_message+"_success:"+v_success;
			}
			//  --(2)、验证业务数据合理性																																							
			//  --(2.1)、验证入口卷对应的作业计划信息存在																																							
			v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount1(v_mch_code,v_entry_coil_no);
			if(v_cnt<=0){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 找不到作业计划信息！";
				return v_message+"_success:"+v_success;
			}else if(v_cnt>1){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"}存在2条或以上的作业计划信息！";
				return v_message+"_success:"+v_success;
			}else{
				List<PlnRollingPlanDetail> v_rec_pln_d_list=this.getMapper(PlnRollingPlanDetailMapper.class).doQuery3(v_mch_code, v_entry_coil_no);
				v_rec_pln_d=v_rec_pln_d_list.get(0);
			}
			//  --(2.2)、验证已下发过PDI
//			if(v_rec_pln_d.getSend_flag()==null || "0".equals(v_rec_pln_d.getSend_flag())){
//				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 还未下发指示顺序或PDI数据！";
//				return v_message+"_success:"+1;
//			}
			//  --(2.3)、验证当前还未生产交工
			MesRcmM mCross = new MesRcmM();
			mCross.setSchedule_no(v_rec_pln_d.getRl_plan_no());
			mCross.setMaterial_no(v_entry_coil_no);
			v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
			if(v_cnt>0){
				List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
			    MesRcmM v_rec_Roll_m =lmcam.get(0);
			    if("1".equals(v_rec_Roll_m.getHand_over_status())){
			    	v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 已生产交工！";
			    	return v_message+"_success:"+v_success;
			    }
			}
			//  --(3)、开始事物：																																							
			//  --(3.1)、修改指示状态																																							
			this.getMapper(PlnRollingPlanDetailMapper.class).doUpdate3(v_operator, v_rec_pln_d.getRl_plan_no(), v_entry_coil_no);
			//  --(4)、提交事务
			//唯一标示操作成功的地方
			v_success=1;
			v_message="Roll01L2Revoke L2指示删除电文处理成功！"+"_success:"+v_success;
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2Revoke L2指示删除电文处理失败！"+e.getMessage().substring(0,200)+"_success:"+v_success;
			}else{
				v_message="Roll01L2Revoke L2指示删除电文处理失败！"+e.getMessage()+"_success:"+v_success;
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	
	/**
	  	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Revoke_d 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_ENTRY_COIL_NO（入口卷号）、V_OPERATOR（删除操作人）																																							
		3)、	接口参数 OUT：V_SUCCESS（操作成功标志（1：成功、0：失败））、V_MESSAGE（操作结果信息）																																							
	 * @param v_rec_l3_asw_rvk
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value="tm", rollbackFor=Exception.class)
	public String Roll01L3AswRevoke(IfRoll01L3AnswerRevoke v_rec_l3_asw_rvk,
			String v_message) throws Exception{
		Integer v_flag=null;// --电文发送成功标志
		try{
			//  --(1)、无接口调试时，设置1，直接跳过，否则设置为0
			v_flag=0;// --1：成功、0：失败
			//  --(1)、调用公司接口，将“L3应答L2指示数据删除电文” v_rec_l3_asw_rvk 发送给L2（获取接口执行成功状态：v_flag，错误信息：v_message）
			
			JsonConfig jsonConfig=new JsonConfig();
			jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
			jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
			JSONObject jsonObject=JSONObject.fromObject(v_rec_l3_asw_rvk,jsonConfig);
			System.out.println(jsonObject.toString());
			try{
				log.debug("url:"+ROLLPDI_L2ORDERDELE);
				String url = ROLLPDI_L2ORDERDELE;
				String body = jsonObject.toString();
		        RestfulHttpClient.HttpResponse response = RestfulHttpClient.getClient(url)
		                .post()              //设置post请求
		                .addPostParam("body", "json")
		                .body(body)
		                .addHeader("Content-type", "application/json")   //添加header
		                //.addPathParam("id", "2")        //设置url路径参数
		                //.addQueryParam("test", "value") //设置url请求参数
		                .request();         //发起请求
		        System.out.println(response.getCode());     //响应状态码
		        System.out.println(response.getRequestUrl());//最终发起请求的地址
		        if(response.getCode() == 200){
		            //请求成功
		            //System.out.println(response.getContent());  //响应内容
		            log.debug("responseCONTENT:"+response.getContent());
		            if(response.getContent()!=null && (response.getContent().contains("vsuccess")|| response.getContent().contains("成功"))){//成功往L2的pdi表中插入数据
		            	v_flag=1;
		            	v_message="L3应答L2指示数据删除电文下发成功！";
		            }else{
		            	if(response.getContent()!=null && response.getContent().length()>200){
		    				v_message="已下发L3应答L2指示数据删除电文给L2，插入失败！【"+response.getContent().substring(0,200)+"】";
		    			}else{
		    				v_message="已下发L3应答L2指示数据删除电文给L2，插入失败！【"+response.getContent()+"】";
		    			}
		            }
		        }else{
		        	v_message="下发L3应答L2指示数据删除电文给L2失败！发送请求失败！";
		        }
			}catch(Exception e){
				e.printStackTrace();
				v_message="【通讯过程出错："+e.getMessage()+"】";
			}
			
			
			
			
			//  --(1.1)、电文发送失败（失败状态，根据接口提供定义确定）
			if(v_flag==0){
				v_message="Roll01L3AswRevoke L3应答L2指示数据删除电文发送失败！"+v_message;
				return v_message;
			}
			//  --(1.2)、电文发送成功（成功状态，根据接口提供定义确定），插入 L3应答L2指示数据删除 记录																																			
			this.getMapper(IfRoll01L3AnswerRevokeMapper.class).insert(v_rec_l3_asw_rvk);
			// --(1.2.1)、提交事务
			v_message="Roll01L3AswRevoke L3应答L2指示数据删除电文发送成功！";
		}catch(Exception e){
			e.printStackTrace();
		    //--(1.2.2)、捕获未定义的异常，提示信息最多200字符																																							
		    //--(1.2.2.1)、电文发送成功（成功状态，根据接口提供定义确定）																																							
			if(v_flag==1){
				// --部分成功（电文已下发成功，但记录未写成功）
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3AswRevoke L3应答L2指示数据删除电文发送成功！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3AswRevoke L3应答L2指示数据删除电文发送成功！"+e.getMessage();
				}
			}else{
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3AswRevoke L3应答L2指示数据删除电文发送失败！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3AswRevoke L3应答L2指示数据删除电文发送失败！"+e.getMessage();
				}
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2开始生产电文时调用；																																							
		2)、	此接口参数为“L2开始生产电文JSON对象”（电文编号：DR3E05）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2ProduceStart(IfRoll01L2PrdStr json){
		String v_message="";
		String v_mch_code="M0008";
		//  --(1)、参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_prd_str 代替描述
		IfRoll01L2PrdStr v_rec_l2_prd_str=json;
		if(json==null ){
			v_message="参数错误：二级接口-轧机_L2_开始生产为空";
			return v_message;
		}
		//  --(1.1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_prd_str.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_prd_str.setMsg_time(new Date());
		}
		//  --(1.2)、将对象，插入L2开始生产表（单独的事务）
		try{
			this.getMapper(IfRoll01L2PrdStrMapper.class).insert(v_rec_l2_prd_str);
		}catch(Exception e){
			e.printStackTrace();
		}
		//  --(2)、调用L2开始生产处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2ProduceStart_d(v_mch_code,v_rec_l2_prd_str,v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_prd_str.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String  v_param = "消息时间 MSG_TIME {"+mes_time+"} 入口卷号 ENTRY_COIL_NO {"+v_rec_l2_prd_str.getEntry_coil_no()+"} 时间 TC_TIME {"+v_rec_l2_prd_str.getTc_time()+"}";																																							
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2ProduceStart",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}

	/**
	 *  1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2ProduceStart 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_PRD_STR（L2开始生产记录）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_prd_str
	 * @param v_message
	 * @return
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2ProduceStart_d(String v_mch_code,
			IfRoll01L2PrdStr v_rec_l2_prd_str, String v_message) throws Exception{
		Integer v_cnt=null;
		PlnRollingPlanDetail v_rec_pln_d=new PlnRollingPlanDetail();
		try{
			//  --(1)、验证传入参数的基本有效性
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--(1.2.1)、获取机台基础信息表中，配置的机台设备代号（设备编号，如1,2,3）
			ComBaseMachine cbm = this.getMapper(ComBaseMachineMapper.class).findById(v_mch_code);
			if(cbm.getMachine_mark()==null){
				v_message="机台代码{"+v_mch_code+"} 设备编号未配置，无法处理！";
				return v_message;
			}
			
			//  --(1.3)、验证入口卷号不为空
			if(v_rec_l2_prd_str.getEntry_coil_no()==null || "".equals(v_rec_l2_prd_str.getEntry_coil_no())){
				v_message="入口卷号{"+v_rec_l2_prd_str.getEntry_coil_no()+"} 未指定入口卷号！";
				return v_message;
			}
			if(v_rec_l2_prd_str.getEntry_coil_no().substring(0, 1).equals("L")){
				List<YdmProductDetail> listypd = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "materailcoilno='"+v_rec_l2_prd_str.getEntry_coil_no()+"'", "", 0, 0);
				if(listypd!=null && listypd.size()==1){
					v_rec_l2_prd_str.setEntry_coil_no(listypd.get(0).getCoilno());
				}
			}
			
			
			
			//--(1.4)、验证电文中“开始生产时间”
			Date v_str_time=null;
			if(v_rec_l2_prd_str.getTc_time()==null || "".equals(v_rec_l2_prd_str.getTc_time())){
				v_str_time=new Date();//--如果“开始生产”事件时刻为空，则赋值为当前时刻
			}else{
				//    --将生产开始时间的字符串，转换日期时间格式（可以在JAVA中转化，此处以PLSQL处理代替描述）
				try {
					List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(v_rec_l2_prd_str.getTc_time());
					v_str_time=li.get(0).getCreate_time();
				} catch (Exception e) {
					e.printStackTrace();
					v_message="电文中“生产开始”事件时刻{"+v_rec_l2_prd_str.getTc_time()+"} 格式转化失败，无法计算日期班次！约定的标准格式【yyyyMMddHHmmss】";
					return v_message;
				}
			}
			String rmDb=DateUtil.formatDate(v_str_time, "yyyy-MM-dd HH:mm:ss");
			String v_date=null,v_ord=null;
			String dbTime=rmDb.substring(11);
			v_date=rmDb.substring(0,10);
			// --(1.1.1)、如果 v_charge_time 的时间>=00:00:00并且<08:00:00，则 作业日期 = v_charge_time 的日期（格式化为yyyy-MM-dd），班次 = "1"，即表示当天晚班；
			if(dbTime.compareTo(DateUtil.NBeginTime)>-1&&dbTime.compareTo(DateUtil.BeginTime)<0){
				v_ord="1";
			}else if(dbTime.compareTo(DateUtil.BeginTime)>-1&&dbTime.compareTo(DateUtil.EndTime)<0){
				v_ord="2";
			}else if(dbTime.compareTo(DateUtil.EndTime)>-1&&dbTime.compareTo(DateUtil.NEndTime)<0){
				v_ord="1";
				SimpleDateFormat formatYmd = new SimpleDateFormat("yyyy-MM-dd");
				Date date;
				try {
					date = formatYmd.parse(v_date);
				} catch (Exception e) {
					return "获取数据库时间失败，请稍后重试";
				}
				Calendar c = Calendar.getInstance();  
		        c.setTime(date);  
		        c.add(Calendar.DAY_OF_MONTH, 1);//日期+1 
		        v_date=formatYmd.format(c.getTime());
			}
			//  --(2)、验证业务数据合理性																																							
			//  --(2.0)、根据计算的日期班次，获取交接班记录的班组																																							
			MesShiftM msm=new MesShiftM();
			msm.setMachine_code(v_mch_code);
			msm.setWrk_date(v_date);
			msm.setWrk_ord(v_ord);
			v_cnt=this.getMapper(MesShiftMMapper.class).count(msm);
			String v_grp=null;
			if(v_cnt<=0){
				v_grp="";// --无交接班记录，则赋空值（交工时，会提示用户完善信息）
			}else{
				//    --否则获取交接班记录中的班组
				List<MesShiftM> lmsm = this.getMapper(MesShiftMMapper.class).find(msm, 0, 0);
				v_grp=lmsm.get(0).getWrk_grp();
			}
			//  --(2.1)、验证入口卷对应的作业计划信息存在  
			v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount1(v_mch_code,v_rec_l2_prd_str.getEntry_coil_no());
			if(v_cnt<=0){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_rec_l2_prd_str.getEntry_coil_no()+"} 找不到作业计划信息！";
				return v_message;  
			}else if(v_cnt>1){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_rec_l2_prd_str.getEntry_coil_no()+"}存在2条或以上的作业计划信息！";
				return v_message; 
			}else{
				List<PlnRollingPlanDetail> v_rec_pln_d_list=this.getMapper(PlnRollingPlanDetailMapper.class).doQuery3(v_mch_code, v_rec_l2_prd_str.getEntry_coil_no());
				v_rec_pln_d=v_rec_pln_d_list.get(0);
			}
			//  --(2.2)、如果已有生产实绩（人工操作或L2重复发送PDO情况下），且已交工，则返回（忽略此电文事件）
			MesRcmM mCross = new MesRcmM();
			mCross.setSchedule_no(v_rec_pln_d.getRl_plan_no());
			mCross.setMaterial_no(v_rec_l2_prd_str.getEntry_coil_no());
			v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
			MesRcmM v_rec_Roll_m=new MesRcmM();
			boolean flag=false;//
			if(v_cnt>0){
				List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
			    v_rec_Roll_m =lmcam.get(0);
			    flag=true;
			    if("1".equals(v_rec_Roll_m.getHand_over_status())){
			    	v_message = "机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} "
			    			+ "入口卷号{"+v_rec_l2_prd_str.getEntry_coil_no()+"} 已生产交工，忽略此电文事件！'";
					return v_message;
			    }
			}
			//  --(2.3)、验证虚拟物料表中，原料卷计划信息存在
			List<PlnMaterielDetail> v_rec_mtr_in_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_in_list==null || v_rec_mtr_in_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_prd_str.getEntry_coil_no()+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+"} 原料卷虚拟物料信息不存在！";																																							
				return v_message;
			}
			PlnMaterielDetail v_rec_mtr_in=v_rec_mtr_in_list.get(0);
			//  --(2.4)、验证原料卷号库存明细记录存在
			List<YdmProductDetail> v_rec_ydm_d_list = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "coilno='"+v_rec_l2_prd_str.getEntry_coil_no()+"'", null, 0, 0);
			if(v_rec_ydm_d_list==null || v_rec_ydm_d_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_prd_str.getEntry_coil_no()+"} 原料卷库存明细记录不存在！";
				return v_message;
			}
			YdmProductDetail v_rec_ydm_d=  v_rec_ydm_d_list.get(0);
			//  --(2.5)、验证虚拟物料表中，出口卷虚拟物料信息存在
			List<PlnMaterielDetail> v_rec_mtr_out_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"mat_object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_out_list==null || v_rec_mtr_out_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_prd_str.getEntry_coil_no()+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+" 出口卷虚拟物料信息不存在！";
				return v_message;
			}
			
			//2018-11-29 只有是已下发状态的钢卷才能下发
			if(v_rec_pln_d!=null){
				if(!("5BRL02".equals(v_rec_pln_d.getStatus()) || "5BRL03".equals(v_rec_pln_d.getStatus()))){
					v_message="当前状态{"+v_rec_pln_d.getStatus()+"}错误";
					return v_message;
				}
			}	
			
			//  --(2.7)、在 v_rec_Roll_m 对象基础上，构建平整主实绩，并插入记录																																							
			//  --(2.7.1)：v_rec_Roll_m 对象可能不为空（之前实绩已存在），则更新部分信息，保留部分信息（未赋值的属性即是保留原有对象的属性值）																																							
			//  --(2.7.2)：v_rec_Roll_m 对象如果为空，请先实例化此对象（plsql示例逻辑无此问题）						
			ComBaseMachine machine2 = new ComBaseMachine();
			machine2.setMachine_code(v_mch_code);
			List<ComBaseMachine> lcbm = this.getMapper(ComBaseMachineMapper.class)
					.find(machine2, 0, 0);
			String v_mch_mark=lcbm.get(0).getMachine_mark();
			if (v_mch_mark == null) {
				return "机台代码：" +v_mch_code+ "\n设备编号未配置，无法处理！";
			}
			String v_process_no="";
			if(!flag){//如果 v_rec_plm_m 对象为空（即之前无生产实绩）
				SimpleDateFormat formatY3 = new SimpleDateFormat("yyMMdd");
				v_process_no = "Z" + formatY3.format(new Date())+lpad(v_mch_mark, 2, "0");
				v_cnt = this.getMapper(MesRcmMMapper.class).doquery(v_process_no);
				if (v_cnt == null) {
					v_cnt = 1;
				}
				v_process_no = v_process_no + lpad(v_cnt.toString(), 3, "0");
				v_rec_Roll_m.setProcess_no(v_process_no);
			}
			
			  v_rec_Roll_m.setMachine_code    ( v_mch_code);// --机台号（区分厂家：艾伯纳、中冶南方、宝信）																																							
			  v_rec_Roll_m.setSchedule_no     ( v_rec_pln_d.getRl_plan_no());// --作业计划号																																							
			  v_rec_Roll_m.setInner_seq       ( v_rec_pln_d.getRl_seq());// --计划内序号																																							
			  v_rec_Roll_m.setMaterial_no_vt  ( v_rec_pln_d.getObject_no_vt());// --虚拟原料卷号																																							
			  v_rec_Roll_m.setPln_steel_code  ( v_rec_mtr_in.getSteel_code());// --计划原料卷牌号																																							
			  v_rec_Roll_m.setPln_mtr_thk     ( v_rec_mtr_in.getThick());// --计划原料卷厚度																																							
			  v_rec_Roll_m.setPln_mtr_wdt     ( v_rec_mtr_in.getWidth());// --计划原料卷宽度																																							
			  v_rec_Roll_m.setPln_mtr_len     ( v_rec_mtr_in.getLength());// --计划原料卷长度																																							
			  v_rec_Roll_m.setPln_mtr_inn_dia ( v_rec_mtr_in.getDiameter_inn());// --计划原料卷内径																																							
			  v_rec_Roll_m.setPln_mtr_out_dia ( v_rec_mtr_in.getDiameter_out());// --计划原料卷外径																																							
			  v_rec_Roll_m.setPln_mtr_thr_wgt ( v_rec_mtr_in.getSingle_weight());// --计划原料卷理重																																							
			  v_rec_Roll_m.setMaterial_no     ( v_rec_l2_prd_str.getEntry_coil_no());// --原料卷号																																							
			  v_rec_Roll_m.setMaterial_no_src ( v_rec_ydm_d.getMaterailcoilno());// --原始卷号																																							
			  v_rec_Roll_m.setMtr_thk         ( v_rec_ydm_d.getThick());// --原料卷厚度																																							
			  v_rec_Roll_m.setMtr_wdt         ( v_rec_ydm_d.getWidth());// --原料卷宽度																																							
			  v_rec_Roll_m.setMtr_len         ( v_rec_ydm_d.getLength());// --原料卷长度																																							
			  v_rec_Roll_m.setMtr_inn_dia     ( v_rec_ydm_d.getDiameter_inn());// --原料卷内径																																							
			  v_rec_Roll_m.setMtr_out_dia     ( v_rec_ydm_d.getDiameter_out());// --原料卷外径																																							
			  if(v_rec_ydm_d.getTheoryweight()!=null){
				  v_rec_Roll_m.setMtr_thr_wgt     ( v_rec_ydm_d.getTheoryweight());// --原料卷理重	
			  }else{
				  v_rec_Roll_m.setMtr_thr_wgt     (v_rec_ydm_d.getFactweight());// --原料卷理重	
			  }
			  v_rec_Roll_m.setMtr_act_wgt     ( v_rec_ydm_d.getFactweight());// --原料卷实重																																							
			  v_rec_Roll_m.setSteel_code      ( v_rec_ydm_d.getSteelcode());// --原料卷牌号
			  
//			  if(!flag){//如果 v_rec_Roll_m 对象为空（即之前无生产实绩），则覆盖 作业日期、班次、班组（与生产开始不同，请注意）
//				  v_rec_Roll_m.setWrk_date     ( v_date);// --作业日期（YYYY-MM-DD）																																							
//				  v_rec_Roll_m.setWrk_ord      ( v_ord); //--作业班次（0常白班、1晚班、2白班、3中班）																																							
//				  v_rec_Roll_m.setWrk_grp      ( v_grp);// --作业班组（0常白班、1甲班、2乙班、3丙班、4丁班）																																							
//				  v_rec_Roll_m.setFeeding_time ( v_str_time); //--上料时间		
//				  
//			  }
			  if(v_rec_Roll_m.getWrk_date()==null){
				  v_rec_Roll_m.setWrk_date     ( v_date);// --作业日期（YYYY-MM-DD）									
			  }
			  if(v_rec_Roll_m.getWrk_grp()==null){
				  v_rec_Roll_m.setWrk_grp      ( v_grp);// --作业班组（0常白班、1甲班、2乙班、3丙班、4丁班）			
			  }
			  if(v_rec_Roll_m.getWrk_ord()==null){
				  v_rec_Roll_m.setWrk_ord      ( v_ord); //--作业班次（0常白班、1晚班、2白班、3中班）				
			  }
			  if(v_rec_Roll_m.getFeeding_time()==null){
				  v_rec_Roll_m.setFeeding_time ( v_str_time); //--上料时间	
			  }
			  
			  v_rec_Roll_m.setTp_str_time(v_str_time); //--生产开始时间
			  v_rec_Roll_m.setMemo             ( null);// --备注																																							
			  v_rec_Roll_m.setHand_over_status ( "0");// --交工状态																																							
			  v_rec_Roll_m.setHand_over_time   ( null);// --交工时间																																							
			  v_rec_Roll_m.setHand_over_opr    ( null);// --交工人																																							

			  if(!flag){
				  //  --如果 v_rec_Roll_m 对象为空（即之前无生产实绩），则：
				  v_rec_Roll_m.setCreate_opr( "L2_DR3E05");// --操作人																																							
				  v_rec_Roll_m.setCreate_time( new Date());// --操作时间																																							
			  }else{
				  //  --如果 v_rec_Roll_m 对象不为空（即之前存在生产实绩），则（创建人、创建时间保留原值）：
				  v_rec_Roll_m.setUpdate_opr("L2_DR3E05");// --修改人																																							
				  v_rec_Roll_m.setUpdate_time(new Date()) ;//--修改时间																																							
			  }
			  
			  //--(3)、开始事物：																																							
			  //--(3.0)、更新生产跟踪表	??	
			  try{
				  int count = this.getMapper(MesRcmTrcMapper.class).countWithCondition(null,"machine_code='"+v_mch_code+"'"); 
				  if(count<=0){
					  	MesRcmTrc mcst=new MesRcmTrc();
					  	mcst.setMachine_code(v_mch_code);
					  	mcst.setCur_coil_no(v_rec_l2_prd_str.getEntry_coil_no());
					  	mcst.setCur_str_time(v_str_time);
					  	mcst.setUpdate_program("Roll01L2ProduceStart");
					  	mcst.setUpdate_time(new Date());
						this.getMapper(MesRcmTrcMapper.class).insert(mcst);
				  }else{
					  MesRcmTrc v_rec_Roll_trc = this.getMapper(MesRcmTrcMapper.class).findById(v_mch_code);
					  //    --(3.0.1)、如果生产结束入口卷号 <> 生产跟踪表的当前钢卷号
					  if(!v_rec_l2_prd_str.getEntry_coil_no().equals(v_rec_Roll_trc.getCur_coil_no())){
						    MesRcmTrc mcst=new MesRcmTrc();
						  	mcst.setMachine_code(v_mch_code);
						  	mcst.setLst_coil_no(v_rec_Roll_trc.getCur_coil_no());
						  	mcst.setLst_str_time(v_rec_Roll_trc.getCur_str_time());
						  	mcst.setLst_end_time(null);
						  	mcst.setCur_coil_no(v_rec_l2_prd_str.getEntry_coil_no());
						  	mcst.setCur_str_time(v_str_time);
						  	mcst.setUpdate_program("Roll01L2ProduceStart");
						  	mcst.setUpdate_time(new Date());
							this.getMapper(MesRcmTrcMapper.class).update(mcst);
					  }else{
						  MesRcmTrc mcstcc=new MesRcmTrc();
						  mcstcc.setMachine_code(v_mch_code);
						  mcstcc.setCur_str_time(v_str_time);
						  mcstcc.setUpdate_program("Roll01L2ProduceStart");
						  mcstcc.setUpdate_time(new Date());
						  this.getMapper(MesRcmTrcMapper.class).update(mcstcc);
					  }
				  }
			  }catch(Exception e){
				  e.printStackTrace();
			  }
			  
			  //  --(3.1)、删除可能存在的平整作业实绩记录
			  this.getMapper(MesRcmMMapper.class).doDelete1(v_rec_pln_d.getRl_plan_no(),v_rec_l2_prd_str.getEntry_coil_no());
			  //  --(3.2)、插入平整作业实绩记录
			  this.getMapper(MesRcmMMapper.class).insert(v_rec_Roll_m);
			  
			  //--(3.3)、调用生产管理接口，执行业计划状态、物料进程状态相关操作（接口由生产管理模块提供）；；																																							
			  //--(3.3.1)、注意：可能在收到此PDO前，已执行过上料操作，并进行了此接 口的操作，要求能正常处理，不能影响上述操作																																							
																																										
			  //--(3.4)、调用物流模块接口，执行原料卷生产投料出库相关操作（接口由物流模块提供）；																																							
			  //--(3.4.1)、注意：可能在收到此PDO前，已执行过上料操作，原料卷可能已投料出库，此时不能影响上述操作																																							
				MesRcmM  mcsm=new MesRcmM();
				mcsm.setMachine_code(v_mch_code);//机台号
				mcsm.setSchedule_no(v_rec_pln_d.getRl_plan_no());//作业计划号
				mcsm.setMaterial_no(v_rec_l2_prd_str.getEntry_coil_no());//投料卷号
				mcsm.setMaterial_no_vt(v_rec_pln_d.getObject_no_vt());//虚拟卷号 
				List<MesRcmM> lmcsm=new ArrayList<MesRcmM>();
				//时间
				SimpleDateFormat dfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");//设置日期格式
			    String date = dfs.format(new Date());// new Date()为获取当前系统时间，也可使用当前时间戳
			    mcsm.setMemo(date);
			    lmcsm.add(mcsm);
			   //调用生产管理接口验证作业计划状态能执行此操作
				boolean flag2=true;
				try{
					this.getBean(MesApiRollingPlanImpl.class).MesRcmMAddValid(lmcsm);
				}catch(Exception e){
					flag2=false;
					e.printStackTrace();
				}
				if(flag2){
					//调用生产管理接口，更改业计划状态（主表、从表）、原料虚拟物料进程状态
					this.getBean(MesApiRollingPlanImpl.class).MesRcmMAdd(lmcsm);
				}
				
				//调用物流模块（仓库管理）接口，对原料卷进行生产投料出库操作（接口由物流模块提供）；
				YdmProductOutlist ypo=new YdmProductOutlist();
				ypo.setCoilno(v_rec_l2_prd_str.getEntry_coil_no());
				ypo.setOuttype("500501");
				v_cnt = this.getMapper(YdmProductOutlistMapper.class).count(ypo);
				if(v_cnt<=0){
					CommonPage<YdmProductDetail> cp2=new CommonPage<YdmProductDetail>();
					YdmProductDetail ypdu=new YdmProductDetail();
					ypdu.setCoilno(v_rec_l2_prd_str.getEntry_coil_no());//注意
					// 传入操作时间字符串带毫秒
					ypdu.setMemo(date);
					cp2.setObject(ypdu);
					this.getBean(LmsApiServiceImpl.class).doOutStorage(cp2);
				}
			v_message = "Roll01L2ProduceStart L2开始生产电文处理成功！";  
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2ProduceStart L2开始生产电文处理失败！"+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2ProduceStart L2开始生产电文处理失败！"+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}

	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2钢卷回退实绩电文时调用；																																							
		2)、	此接口参数为“L2钢卷回退实绩电文JSON对象”（电文编号：DR3E07）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2Reject(IfRoll01L2Reject json){
		String v_message="";
		String v_mch_code="M0008";
		//  --(1)、先将参数转换为Java实体类，此处以 v_rec_l2_reject 代替描述
		IfRoll01L2Reject v_rec_l2_reject=json;
		if(json==null){
			v_message="参数错误：二级接口-轧机_L2_钢卷回退实绩为空";
			return v_message;
		}
		//  --(1.1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_reject.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_reject.setMsg_time(new Date());
		}
		//  --(1.2)、将对象，插入L2钢卷回退实绩表（单独的事务）
		try{
			this.getMapper(IfRoll01L2RejectMapper.class).insert(v_rec_l2_reject);
		}catch(Exception e){
			e.printStackTrace();
		}
		//  --(2)、调用L2钢卷回退实绩处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2Reject_d(v_mch_code,v_rec_l2_reject,v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_reject.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String v_param = "消息时间 MSG_TIME {"+mes_time+"} 回退钢卷号 REJECT_COIL_NO {"+v_rec_l2_reject.getReject_coil_no()+"} "
					+ "入口钢卷号 ENTRY_COIL_NO {"+v_rec_l2_reject.getEntry_coil_no()+"} 材料标志 COIL_FLAG {"+v_rec_l2_reject.getCoil_flag()+"} "
							+ "回退方式 REJECT_MODE {"+v_rec_l2_reject.getReject_mode()+"} 回退卷长 REJECT_COIL_LENGTH {"+v_rec_l2_reject.getReject_coil_length()+"} "
									+ "回退卷重 REJECT_COIL_WEIGHT {"+v_rec_l2_reject.getReject_coil_weight()+"} 回退卷外径 REJECT_OUTER_DIAMETER {"+																																						
			             v_rec_l2_reject.getReject_outer_diameter() +"} 回退原因代码 REJECT_REASON_CODE {"+v_rec_l2_reject.getReject_reason_code() +"} "
			             		+ "封闭代码 WITHHOLDING_FLAG {"+v_rec_l2_reject.getWithholding_flag()	+"} 封闭原因代码 WITHHOLDING_REASON {"+
			             v_rec_l2_reject.getWithholding_reason() +"} 封闭责任者代码 USER_ID {"+																																						
			             v_rec_l2_reject.getUser_id() +"} 回退时间 REJECT_TIME {"+																																							
			             v_rec_l2_reject.getReject_time()+ "} 班次 SHIFT {"+																																							
			             v_rec_l2_reject.getShift() +"} 班别 CREW {"+ v_rec_l2_reject.getCrew()+"}";																																							
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2Reject",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}
	
	
	/**
	 * 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Reject 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_REJECT（L2钢卷回退实绩对象）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_reject
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2Reject_d(String v_mch_code,
			IfRoll01L2Reject v_rec_l2_reject, String v_message) throws Exception{
		
		IfRoll01L3AnswerReject v_rec_l3_asw_reject=new IfRoll01L3AnswerReject();
		Integer v_success=null;
		try{
			//  --(1)、调用 L2钢卷回退实绩 处理函数
			try{
				v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2Reject_d_d(v_mch_code,v_rec_l2_reject,
						v_success,v_message);
			}catch(Exception e){
				e.printStackTrace();
				v_message=e.getMessage();
			}
			//  --(1.1)、构造 L3应答L2钢卷回退实绩 电文																																							
			//  --(1.1.1)、L3处理L2钢卷回退实绩电文成功（1：成功）																																							
			if(v_message==null){
				v_message="";
			}
			String v_success_str="";
			//对v_message和v_success进行处理
			if(v_message.contains("_success:")){
				v_success_str=v_message.substring(v_message.length()-1);
				v_message=v_message.substring(0, v_message.lastIndexOf("_success"));
			}
			if("1".equals(v_success_str)){
				v_rec_l3_asw_reject.setResult("0");// --处理结果（0：成功、1：错误）
			}else{
				v_rec_l3_asw_reject.setResult("1");//--处理标志（0：成功、1：不成功）
			}
			v_rec_l3_asw_reject.setReject_coil_no(v_rec_l2_reject.getReject_coil_no());//--回退卷号
			v_rec_l3_asw_reject.setSend_time(new Date());
			v_rec_l3_asw_reject.setSend_opr("L3");//--下发人
			//  --(2)、调用 L3应答L2钢卷回退实绩 处理函数
			String v_message2="";
			try{
				v_message2=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3AswReject(v_rec_l3_asw_reject,v_message2);
			}catch(Exception e){
				e.printStackTrace();
				v_message2=e.getMessage();
			}
			String send_time=DateUtil.formatDate(v_rec_l3_asw_reject.getSend_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(4)、拼接返回字符串
			String  v_param = "下发时间 SEND_TIME {"+send_time+"} 下发人 SEND_OPR {"+v_rec_l3_asw_reject.getSend_opr()+"} "
			  		+ "回退卷号 REJECT_COIL_NO {"+v_rec_l3_asw_reject.getReject_coil_no()+"} 处理结果（0：成功、1：错误） RESULT {"+v_rec_l3_asw_reject.getResult()+"} "
			  				+ "预留 RESERVE {"+v_rec_l3_asw_reject.getReserve()+"}";																																							
			//  --(5)、写接口日志：与业务处理分开，单独的事务
			try{
				this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L3AswReject",v_param,v_message2);
			}catch(Exception e){
				e.printStackTrace();
			}
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2Reject_d处理出错："+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2Reject_d处理出错："+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	

	/**
	 * 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Reject_d 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_REJECT（L2钢卷回退实绩对象）																																							
		3)、	接口参数 OUT：V_SUCCESS（操作成功标志（1：成功、0：失败））、V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_reject
	 * @param v_success
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value="tm", rollbackFor=Exception.class)
	public String Roll01L2Reject_d_d(String v_mch_code,
			IfRoll01L2Reject v_rec_l2_reject, Integer v_success, String v_message) throws Exception{
		Integer v_cnt=null;
		// --(0)、置输出参数：操作成功标志为0：失败
		v_success=0;
		PlnRollingPlanDetail v_rec_pln_d=new PlnRollingPlanDetail();
		try{
			//  --(1)、验证传入参数的基本有效性
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--(1.2.1)、获取机台基础信息表中，配置的机台设备代号（设备编号，如1,2,3）
			ComBaseMachine cbm = this.getMapper(ComBaseMachineMapper.class).findById(v_mch_code);
			if(cbm.getMachine_mark()==null){
				v_message="机台代码{"+v_mch_code+"} 设备编号未配置，无法处理！";
				return v_message;
			}
			//  --(1.3)、验证入口卷号不为空
			if(v_rec_l2_reject.getEntry_coil_no()==null || "".equals(v_rec_l2_reject.getEntry_coil_no())){
				v_message="入口卷号{"+v_rec_l2_reject.getEntry_coil_no()+"} 未指定入口卷号！";
				return v_message;
			}
			if(v_rec_l2_reject.getEntry_coil_no().substring(0, 1).equals("L")){
				List<YdmProductDetail> listypd = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "materailcoilno='"+v_rec_l2_reject.getEntry_coil_no()+"'", "", 0, 0);
				if(listypd!=null && listypd.size()==1){
					v_rec_l2_reject.setEntry_coil_no(listypd.get(0).getCoilno());
				}
			}
			
			
			//  --(1.4)、验证回退方式（1： 整卷回退、2：半卷回退）
			if(v_rec_l2_reject.getReject_mode()==null || "".equals(v_rec_l2_reject.getReject_mode())){
				v_message="回退方式{"+v_rec_l2_reject.getReject_mode()+"} 未指定，系统无法处理！";
				return v_message;
			}else if(strToLong(v_rec_l2_reject.getReject_mode()).longValue()!=1 && strToLong(v_rec_l2_reject.getReject_mode()).longValue()!=2){
				v_message="回退方式{"+v_rec_l2_reject.getReject_mode()+"} 代码无法识别！";
				return v_message;
			}
			if(strToLong(v_rec_l2_reject.getReject_mode()).longValue()==1){
				v_message="整卷回退 的情况，系统不做处理，由人工到MES系统取消实绩，恢复为计划";
				return v_message;
			}
			
			Date v_time=null;
			//  --(2)、只处理“半卷回退”的情况（整卷回退 的情况，系统不做处理，由人工到MES系统取消实绩，恢复为计划）
			if("2".equals(v_rec_l2_reject.getReject_mode())){
				//    --(2.1)、验证电文中“回退时间（YYYYMMDDHHMMSS）”
				if(v_rec_l2_reject.getReject_time()==null || "".equals(v_rec_l2_reject.getReject_time())){
					v_time=new Date();//--如果回退时间为空，则赋值为当前时刻
				}else{
					//    --(2.1.1)、将回退时间的字符串，转换日期时间格式（可以在JAVA中转化，此处以PLSQL处理代替描述）
					try {
						List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(v_rec_l2_reject.getReject_time());
						v_time=li.get(0).getCreate_time();
					} catch (Exception e) {
						e.printStackTrace();
						v_message="电文中“回退时间”{"+v_rec_l2_reject.getReject_time()+"} 格式转化失败，无法计算日期班次！约定的标准格式【yyyyMMddHHmmss】";
						return v_message;
					}
				}
			}
			
			String rmDb=DateUtil.formatDate(v_time, "yyyy-MM-dd HH:mm:ss");
			String v_date=null,v_ord=null;
			String dbTime=rmDb.substring(11);
			v_date=rmDb.substring(0,10);
			// --(1.1.1)、如果 v_charge_time 的时间>=00:00:00并且<08:00:00，则 作业日期 = v_charge_time 的日期（格式化为yyyy-MM-dd），班次 = "1"，即表示当天晚班；
			if(dbTime.compareTo(DateUtil.NBeginTime)>-1&&dbTime.compareTo(DateUtil.BeginTime)<0){
				v_ord="1";
			}else if(dbTime.compareTo(DateUtil.BeginTime)>-1&&dbTime.compareTo(DateUtil.EndTime)<0){
				v_ord="2";
			}else if(dbTime.compareTo(DateUtil.EndTime)>-1&&dbTime.compareTo(DateUtil.NEndTime)<0){
				v_ord="1";
				SimpleDateFormat formatYmd = new SimpleDateFormat("yyyy-MM-dd");
				Date date;
				try {
					date = formatYmd.parse(v_date);
				} catch (Exception e) {
					return "获取数据库时间失败，请稍后重试";
				}
				Calendar c = Calendar.getInstance();  
		        c.setTime(date);  
		        c.add(Calendar.DAY_OF_MONTH, 1);//日期+1 
		        v_date=formatYmd.format(c.getTime());
			}
			//  --(2)、验证业务数据合理性																																							
			//    --(2.3)、根据计算的日期班次，获取交接班记录的班组																																						
			MesShiftM msm=new MesShiftM();
			msm.setMachine_code(v_mch_code);
			msm.setWrk_date(v_date);
			msm.setWrk_ord(v_ord);
			v_cnt=this.getMapper(MesShiftMMapper.class).count(msm);
			String v_grp=null;
			if(v_cnt<=0){
				  //      --(2.3.1)、电文中 班别（A：甲、B：乙、C：丙、D：丁），对应MES系统（1：甲、2：乙、3：丙、4：丁）
				  String l2_grp=v_rec_l2_reject.getCrew(); //--无交接班记录，是使用电文中的生产班别
				  if("A".equals(l2_grp)){
					  v_grp = "1"; //--无交接班记录，是使用电文中的生产班别
				  }else if("B".equals(l2_grp)){
					  v_grp = "2"; //--无交接班记录，是使用电文中的生产班别
				  }else if("C".equals(l2_grp)){
					  v_grp = "3"; //--无交接班记录，是使用电文中的生产班别
				  }else if("D".equals(l2_grp)){
					  v_grp = "4"; //--无交接班记录，是使用电文中的生产班别
				  }
			}else{
				//    --否则获取交接班记录中的班组
				List<MesShiftM> lmsm = this.getMapper(MesShiftMMapper.class).find(msm, 0, 0);
				v_grp=lmsm.get(0).getWrk_grp();
			}
			// --(2.4)、验证入口卷对应的作业计划信息存在
			v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount1(v_mch_code,v_rec_l2_reject.getEntry_coil_no());
			if(v_cnt<=0){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_rec_l2_reject.getEntry_coil_no()+"} 找不到作业计划信息！";
				return v_message;  
			}else if(v_cnt>1){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_rec_l2_reject.getEntry_coil_no()+"}存在2条或以上的作业计划信息！";
				return v_message; 
			}else{
				List<PlnRollingPlanDetail> v_rec_pln_d_list=this.getMapper(PlnRollingPlanDetailMapper.class).doQuery3(v_mch_code, v_rec_l2_reject.getEntry_coil_no());
				v_rec_pln_d=v_rec_pln_d_list.get(0);
			}
			//    --(2.5)、如果已有生产实绩（人工操作或L2重复发送PDO情况下），且已交工，则返回（忽略此电文事件）
			MesRcmM mCross = new MesRcmM();
			mCross.setSchedule_no(v_rec_pln_d.getRl_plan_no());
			mCross.setMaterial_no(v_rec_l2_reject.getEntry_coil_no());
			v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
			MesRcmM v_rec_Roll_m=new MesRcmM();
			boolean flag=false;//
			if(v_cnt>0){
				List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
			    v_rec_Roll_m =lmcam.get(0);
			    flag=true;
			    if("1".equals(v_rec_Roll_m.getHand_over_status())){
			    	v_message = "机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} "
			    			+ "入口卷号{"+v_rec_l2_reject.getEntry_coil_no()+"} 已生产交工，忽略此电文事件！'";
					return v_message;
			    }
			}
			//    --(2.6)、验证虚拟物料表中，原料卷计划信息存在
			List<PlnMaterielDetail> v_rec_mtr_in_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_in_list==null || v_rec_mtr_in_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_reject.getEntry_coil_no()+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+"} 原料卷虚拟物料信息不存在！";																																							
				return v_message;
			}
			PlnMaterielDetail v_rec_mtr_in=v_rec_mtr_in_list.get(0);
			//    --(2.7)、验证原料卷号库存明细记录存在
			List<YdmProductDetail> v_rec_ydm_d_list = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "coilno='"+v_rec_l2_reject.getEntry_coil_no()+"'", null, 0, 0);
			if(v_rec_ydm_d_list==null || v_rec_ydm_d_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_reject.getEntry_coil_no()+"} 原料卷库存明细记录不存在！";
				return v_message;
			}
			YdmProductDetail v_rec_ydm_d=  v_rec_ydm_d_list.get(0);
			//    --(2.8)、验证虚拟物料表中，出口卷虚拟物料信息存在
			List<PlnMaterielDetail> v_rec_mtr_out_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"mat_object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_out_list==null || v_rec_mtr_out_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_reject.getEntry_coil_no()+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+" 出口卷虚拟物料信息不存在！";
				return v_message;
			}
			
			//2018-11-29 只有是已下发状态的钢卷才能下发
			if(v_rec_pln_d!=null){
				if(!("5BRL02".equals(v_rec_pln_d.getStatus()) || "5BRL03".equals(v_rec_pln_d.getStatus()))){
					v_message="当前状态{"+v_rec_pln_d.getStatus()+"}错误";
					return v_message;
				}
			}
			
			//    --(2.10)、计算吊销卷号
			String v_reject_coil_no=null;
			for(int idx=1;idx<=9;idx++){
				//      --(2.10.1)、吊销卷号编码规则：原料卷号（8位最初始原料卷号） + 1位工序代号（平整P）+ 2位设备代号（01-99）+ 'R' + 1位流水（1 - 9）
				v_reject_coil_no=v_rec_l2_reject.getEntry_coil_no().substring(0, 8) + "P"+lpad(cbm.getMachine_mark(), 2, "0")+"R"+idx;
				String schedule_no=null;
				String material_no=null;
				if(v_rec_Roll_m==null){
					schedule_no="NULL";
					material_no="NULL";
				}else{
					schedule_no=v_rec_Roll_m.getSchedule_no()==null?"NULL":v_rec_Roll_m.getSchedule_no();
					material_no=v_rec_Roll_m.getMaterial_no()==null?"NULL":v_rec_Roll_m.getMaterial_no();
				}
				v_cnt=this.getMapper(MesRcmMMapper.class).doCount2(v_reject_coil_no,schedule_no,material_no);
				//  --(2.10.2)、--吊销卷号未占用
				if(v_cnt==0){
					break;
				}
			}
			//    --(2.10.3)、--吊销卷号无法生成(1-9序号全部被使用)
			if(v_cnt>0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_reject.getEntry_coil_no()+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+"吊销卷号生成失败，序号已全部占用！";																																							
				return v_message;
			}
		    // --(2.11)、在 v_rec_Roll_m 对象基础上，构建平整主实绩，并插入记录																																							
		    // --(2.11.1)：v_rec_Roll_m 对象可能不为空（之前实绩已存在），则更新部分信息，保留部分信息（未赋值的属性即是保留原有对象的属性值）																																							
		    // --(2.11.2)：v_rec_Roll_m 对象如果为空，请先实例化此对象（plsql示例逻辑无此问题）	
			ComBaseMachine machine2 = new ComBaseMachine();
			machine2.setMachine_code(v_mch_code);
			List<ComBaseMachine> lcbm = this.getMapper(ComBaseMachineMapper.class)
					.find(machine2, 0, 0);
			String v_mch_mark=lcbm.get(0).getMachine_mark();
			if (v_mch_mark == null) {
				return "机台代码：" +v_mch_code+ "\n设备编号未配置，无法处理！";
			}
			String v_process_no="";
			if(!flag){//如果 v_rec_plm_m 对象为空（即之前无生产实绩）
				SimpleDateFormat formatY3 = new SimpleDateFormat("yyMMdd");
				v_process_no = "Z" + formatY3.format(new Date())+lpad(v_mch_mark, 2, "0");
				v_cnt = this.getMapper(MesRcmMMapper.class).doquery(v_process_no);
				if (v_cnt == null) {
					v_cnt = 1;
				}
				v_process_no = v_process_no + lpad(v_cnt.toString(), 3, "0");
				v_rec_Roll_m.setProcess_no(v_process_no);
			}
			
			
			
			  v_rec_Roll_m.setMachine_code    ( v_mch_code);// --机台号（区分厂家：艾伯纳、中冶南方、宝信）																																							
			  v_rec_Roll_m.setSchedule_no     ( v_rec_pln_d.getRl_plan_no());// --作业计划号																																							
			  v_rec_Roll_m.setInner_seq       ( v_rec_pln_d.getRl_seq());// --计划内序号																																							
			  v_rec_Roll_m.setMaterial_no_vt  ( v_rec_pln_d.getObject_no_vt());// --虚拟原料卷号																																							
			  v_rec_Roll_m.setPln_steel_code  ( v_rec_mtr_in.getSteel_code());// --计划原料卷牌号																																							
			  v_rec_Roll_m.setPln_mtr_thk     ( v_rec_mtr_in.getThick());// --计划原料卷厚度																																							
			  v_rec_Roll_m.setPln_mtr_wdt     ( v_rec_mtr_in.getWidth());// --计划原料卷宽度																																							
			  v_rec_Roll_m.setPln_mtr_len     ( v_rec_mtr_in.getLength());// --计划原料卷长度																																							
			  v_rec_Roll_m.setPln_mtr_inn_dia ( v_rec_mtr_in.getDiameter_inn());// --计划原料卷内径																																							
			  v_rec_Roll_m.setPln_mtr_out_dia ( v_rec_mtr_in.getDiameter_out());// --计划原料卷外径																																							
			  v_rec_Roll_m.setPln_mtr_thr_wgt ( v_rec_mtr_in.getSingle_weight());// --计划原料卷理重																																							
			  v_rec_Roll_m.setMaterial_no     ( v_rec_l2_reject.getEntry_coil_no());// --原料卷号																																							
			  v_rec_Roll_m.setMaterial_no_src ( v_rec_ydm_d.getMaterailcoilno());// --原始卷号																																							
			  v_rec_Roll_m.setMtr_thk         ( v_rec_ydm_d.getThick());// --原料卷厚度																																							
			  v_rec_Roll_m.setMtr_wdt         ( v_rec_ydm_d.getWidth());// --原料卷宽度																																							
			  v_rec_Roll_m.setMtr_len         ( v_rec_ydm_d.getLength());// --原料卷长度																																							
			  v_rec_Roll_m.setMtr_inn_dia     ( v_rec_ydm_d.getDiameter_inn());// --原料卷内径																																							
			  v_rec_Roll_m.setMtr_out_dia     ( v_rec_ydm_d.getDiameter_out());// --原料卷外径																																							
			  if(v_rec_ydm_d.getTheoryweight()!=null){
				  v_rec_Roll_m.setMtr_thr_wgt     ( v_rec_ydm_d.getTheoryweight());// --原料卷理重	
			  }else{
				  v_rec_Roll_m.setMtr_thr_wgt     (v_rec_ydm_d.getFactweight());// --原料卷理重	
			  }																																						
			  v_rec_Roll_m.setMtr_act_wgt     ( v_rec_ydm_d.getFactweight());// --原料卷实重																																							
			  v_rec_Roll_m.setSteel_code      ( v_rec_ydm_d.getSteelcode());// --原料卷牌号
			  
			  if(!flag){//如果 v_rec_Roll_m 对象为空（即之前无生产实绩），则覆盖 作业日期、班次、班组（与生产开始不同，请注意）
				  v_rec_Roll_m.setWrk_date     ( v_date);// --作业日期（YYYY-MM-DD）																																							
				  v_rec_Roll_m.setWrk_ord      ( v_ord); //--作业班次（0常白班、1晚班、2白班、3中班）																																							
				  v_rec_Roll_m.setWrk_grp      ( v_grp);// --作业班组（0常白班、1甲班、2乙班、3丙班、4丁班）																																							
				  v_rec_Roll_m.setFeeding_time ( v_time); //--上料时间		
			  }
			  //    --半卷回退(即:部分卷吊销)信息设置
			  v_rec_Roll_m.setPartial_rejected("1");//--部分原料卷吊销（1是、0否）
			  v_rec_Roll_m.setRejected_coil_no(v_reject_coil_no);// --吊销卷号																																							
			  v_rec_Roll_m.setRejected_coil_thr_wgt ( v_rec_l2_reject.getReject_coil_weight()==null?null:strToLong(v_rec_l2_reject.getReject_coil_weight()).doubleValue()); //--吊销卷理重																																							
			  v_rec_Roll_m.setRejected_coil_act_wgt ( v_rec_l2_reject.getReject_coil_weight()==null?null:strToLong(v_rec_l2_reject.getReject_coil_weight()).doubleValue()); //--吊销卷实重																																							
			  v_rec_Roll_m.setRejected_coil_len     ( v_rec_l2_reject.getReject_coil_length()==null?null:strToLong(v_rec_l2_reject.getReject_coil_length()).doubleValue());// --吊销卷长度（m）																																							
			  v_rec_Roll_m.setRejected_coil_out_dia ( v_rec_l2_reject.getReject_outer_diameter()==null?null:strToLong(v_rec_l2_reject.getReject_outer_diameter()).doubleValue());// --吊销卷外径																																							
			  v_rec_Roll_m.setMemo             ( null);// --备注																																							
			  v_rec_Roll_m.setHand_over_status ( "0");// --交工状态																																							
			  v_rec_Roll_m.setHand_over_time   ( null);// --交工时间																																							
			  v_rec_Roll_m.setHand_over_opr    ( null);// --交工人																																							

			  if(!flag){
				  //  --如果 v_rec_Roll_m 对象为空（即之前无生产实绩），则：
				  v_rec_Roll_m.setCreate_opr( "L2_DR3E07");// --操作人																																							
				  v_rec_Roll_m.setCreate_time( new Date());// --操作时间																																							
			  }else{
				  //  --如果 v_rec_Roll_m 对象不为空（即之前存在生产实绩），则（创建人、创建时间保留原值）：
				  v_rec_Roll_m.setUpdate_opr("L2_DR3E07");// --修改人																																							
				  v_rec_Roll_m.setUpdate_time(new Date()) ;//--修改时间																																							
			  }
			  //    --(2.12)、开始事物																																						
			  //    --(2.12.0)、删除可能存在的平整作业实绩记录
			  this.getMapper(MesRcmMMapper.class).doDelete1(v_rec_pln_d.getRl_plan_no(),v_rec_l2_reject.getEntry_coil_no());
			  //    --(2.12.1)、插入平整作业实绩记录
			  this.getMapper(MesRcmMMapper.class).insert(v_rec_Roll_m);
			  
			  //  --(2.12.2)、调用生产管理接口，执行业计划状态、物料进程状态相关操作（接口由生产管理模块提供）；；																																							
			  //  --(2.12.2.1)、注意：可能在收到此PDO前，已执行过上料操作，并进行了此接口的操作，要求能正常处理，不能影响上述操作																																							
			  																																							
			  //  --(2.12.3)、调用物流模块接口，执行原料卷生产投料出库相关操作（接口由物流模块提供）；																																							
			  //  --(2.12.3.1)、注意：可能在收到此PDO前，已执行过上料操作，原料卷可能已投料出库，此时不能影响上述操作																																							
																																					
				MesRcmM  mcsm=new MesRcmM();
				mcsm.setMachine_code(v_mch_code);//机台号
				mcsm.setSchedule_no(v_rec_pln_d.getRl_plan_no());//作业计划号
				mcsm.setMaterial_no(v_rec_l2_reject.getEntry_coil_no());//投料卷号
				mcsm.setMaterial_no_vt(v_rec_pln_d.getObject_no_vt());//虚拟卷号 
				List<MesRcmM> lmcsm=new ArrayList<MesRcmM>();
				//时间
				SimpleDateFormat dfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");//设置日期格式
			    String date = dfs.format(new Date());// new Date()为获取当前系统时间，也可使用当前时间戳
			    mcsm.setMemo(date);
			    lmcsm.add(mcsm);
			   //调用生产管理接口验证作业计划状态能执行此操作
				boolean flag2=true;
				try{
					this.getBean(MesApiRollingPlanImpl.class).MesRcmMAddValid(lmcsm);
				}catch(Exception e){
					flag2=false;
					e.printStackTrace();
				}
				if(flag2){
					//调用生产管理接口，更改业计划状态（主表、从表）、原料虚拟物料进程状态
					this.getBean(MesApiRollingPlanImpl.class).MesRcmMAdd(lmcsm);
				}
				
				//调用物流模块（仓库管理）接口，对原料卷进行生产投料出库操作（接口由物流模块提供）；
				YdmProductOutlist ypo=new YdmProductOutlist();
				ypo.setCoilno(v_rec_l2_reject.getEntry_coil_no());
				ypo.setOuttype("500501");
				v_cnt = this.getMapper(YdmProductOutlistMapper.class).count(ypo);
				if(v_cnt<=0){
					CommonPage<YdmProductDetail> cp2=new CommonPage<YdmProductDetail>();
					YdmProductDetail ypdu=new YdmProductDetail();
					ypdu.setCoilno(v_rec_l2_reject.getEntry_coil_no());//注意
					// 传入操作时间字符串带毫秒
					ypdu.setMemo(date);
					cp2.setObject(ypdu);
					this.getBean(LmsApiServiceImpl.class).doOutStorage(cp2);
				}
		    v_success=1;//--唯一置为成功的地方
			v_message = "Roll01L2Reject L2钢卷回退实绩电文处理成功！";  
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2Reject L2钢卷回退实绩电文处理失败！"+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2Reject L2钢卷回退实绩电文处理失败！"+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
		
	}

	/**
	 * 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Reject_d 方法调用；																																							
		2)、	接口参数 IN：V_REC_L3_ASW_REJECT（L3应答L2钢卷回退实绩对象）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_rec_l3_asw_reject
	 * @param v_message2
	 * @return
	 * @throws Exception
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value="tm", rollbackFor=Exception.class)
	public String Roll01L3AswReject(IfRoll01L3AnswerReject v_rec_l3_asw_reject,
			String v_message) throws Exception{
		Integer v_flag=null;// --电文发送成功标志
		try{
			//  --(1)、无接口调试时，设置1，直接跳过，否则设置为0
			v_flag=0;// --1：成功、0：失败
			//  --(1)、调用公司接口，将“L3应答L2钢卷回退实绩电文” v_rec_l3_asw_reject 发送给L2（获取接口执行成功状态：v_flag，错误信息：v_message）

			JsonConfig jsonConfig=new JsonConfig();
			jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
			jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
			JSONObject jsonObject=JSONObject.fromObject(v_rec_l3_asw_reject,jsonConfig);
			System.out.println(jsonObject.toString());
			try{
				log.debug("url:"+ROLLPDI_HUITUI);
				String url = ROLLPDI_HUITUI;
				String body = jsonObject.toString();
		        RestfulHttpClient.HttpResponse response = RestfulHttpClient.getClient(url)
		                .post()              //设置post请求
		                .addPostParam("body", "json")
		                .body(body)
		                .addHeader("Content-type", "application/json")   //添加header
		                //.addPathParam("id", "2")        //设置url路径参数
		                //.addQueryParam("test", "value") //设置url请求参数
		                .request();         //发起请求
		        System.out.println(response.getCode());     //响应状态码
		        System.out.println(response.getRequestUrl());//最终发起请求的地址
		        if(response.getCode() == 200){
		            //请求成功
		            //System.out.println(response.getContent());  //响应内容
		            log.debug("responseCONTENT:"+response.getContent());
		            if(response.getContent()!=null && (response.getContent().contains("vsuccess")|| response.getContent().contains("成功"))){//成功往L2的pdi表中插入数据
		            	v_flag=1;
		            	v_message="L3应答L2钢卷回退实绩电文下发成功！";
		            }else{
		            	if(response.getContent()!=null && response.getContent().length()>200){
		    				v_message="已下发L3应答L2钢卷回退实绩电文给L2，插入失败！【"+response.getContent().substring(0,200)+"】";
		    			}else{
		    				v_message="已下发L3应答L2钢卷回退实绩电文给L2，插入失败！【"+response.getContent()+"】";
		    			}
		            }
		        }else{
		        	v_message="下发L3应答L2钢卷回退实绩电文给L2失败！发送请求失败！";
		        }
			}catch(Exception e){
				e.printStackTrace();
				v_message="【通讯过程出错："+e.getMessage()+"】";
			}
			
			// --(1.1)、电文发送失败（失败状态，根据接口提供定义确定）
			if(v_flag==0){
				v_message="Roll01L3AswReject L3应答L2钢卷回退实绩电文发送失败！"+v_message;
				return v_message;
			}
			//  --(1.2)、电文发送成功（成功状态，根据接口提供定义确定），插入 L3应答L2钢卷回退实绩 记录																																		
			this.getMapper(IfRoll01L3AnswerRejectMapper.class).insert(v_rec_l3_asw_reject);
			// --(1.2.1)、提交事务
			v_message="Roll01L3AswReject L3应答L2钢卷回退实绩电文发送成功！";
		}catch(Exception e){
			e.printStackTrace();
		    //--(1.2.2)、捕获未定义的异常，提示信息最多200字符																																							
		    //--(1.2.2.1)、电文发送成功（成功状态，根据接口提供定义确定）																																							
			if(v_flag==1){
				// --部分成功（电文已下发成功，但记录未写成功）
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3AswReject L3应答L2钢卷回退实绩电文发送成功！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3AswReject L3应答L2钢卷回退实绩电文发送成功！"+e.getMessage();
				}
			}else{
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3AswReject L3应答L2钢卷回退实绩电文发送失败！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3AswReject L3应答L2钢卷回退实绩电文发送失败！"+e.getMessage();
				}
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2钢卷生产实绩电文时调用；																																							
		2)、	此接口参数为“L2钢卷生产实绩电文JSON对象”（电文编号：DR3E08）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2Pdo(IfRoll01L2Pdo json){
		String v_message="";
		String v_mch_code="M0008";
		//  --(1)、先将参数转换为Java实体类，此处以 v_rec_l2_pdo 代替描述
		IfRoll01L2Pdo v_rec_l2_pdo=json;
		if(json==null){
			v_message="二级接口-轧机_L2_PDO为空";
			return v_message;
		}
//		if(v_rec_l2_pdo.getSpm_mode()==null || v_rec_l2_pdo.getSpm_mode().longValue()==0){//平整  延伸率
//			v_rec_l2_pdo.setElongation(v_rec_l2_pdo.getElongation_reduction());
//		}else if(v_rec_l2_pdo.getSpm_mode().longValue()==1){//轧制 压下率
//			v_rec_l2_pdo.setReduction(v_rec_l2_pdo.getElongation_reduction());
//		}
		
		//  --(1.0)、创建L2钢卷生产实绩表记录号
		Long max_serial_no=this.getMapper(IfRoll01L2PdoMapper.class).doCount();
		v_rec_l2_pdo.setSerial_no(max_serial_no);
		//  --(1.1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_pdo.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_pdo.setMsg_time(new Date());
		}
		//  --(1.2)、将对象，插入 L2钢卷生产实绩表 以及 L2_PDO_缺陷信息表（单独的事务）																																							
		//  --(1.2.1)、此电文需要拆分为 主从表（1:N），其中缺陷信息为字表（编码时注意处理）																																							
		try{
			this.getMapper(IfRoll01L2PdoMapper.class).insert(v_rec_l2_pdo);
		}catch(Exception ex){
			ex.printStackTrace();
		}
			//--(1.2.2)、缺陷子记录数，根据电文实际情况确认（电文ID：DR3E08） ？？
//			for(int i=1;i<=20;i++){
//				IfRoll01L2PdoDfc itpd=new IfRoll01L2PdoDfc();
//				//itpd.setSerial_no(serial_no);//记录号（由业务接口创建，唯一标识消息）  ？？
//				itpd.setStart_pos(null);//起始位置（m，Calculate from tail, like weldseam position）
//				itpd.setEnd_pos(null);//终止位置（m）
//				Long defect_no=(long)i;
//				itpd.setDefect_no(defect_no);//序号（由业务创建，1 - 99）
//				itpd.setDefect_type("");//缺陷类型代码
//				itpd.setDefect_intensity("1");//缺陷级别（1：slight,、2：medium、3：heavy）
//				//this.getMapper(IfRoll01L2PdoDfcMapper.class).insert(itpd);
//			}
		try{
			if(v_rec_l2_pdo!=null && v_rec_l2_pdo.getDefects().size()>0){
				int i=1;
				for(IfRoll01L2PdoDfc defe:v_rec_l2_pdo.getDefects()){
					IfRoll01L2PdoDfc itpd=new IfRoll01L2PdoDfc();
					//itpd.setSerial_no(serial_no);//记录号（由业务接口创建，唯一标识消息）  ？？
					itpd.setStart_pos(defe.getStart_pos());//起始位置（m，Calculate from tail, like weldseam position）
					itpd.setEnd_pos(defe.getEnd_pos());//终止位置（m）
					Long defect_no=(long)i;
					itpd.setDefect_no(defect_no);//序号（由业务创建，1 - 99）
					itpd.setDefect_type(defe.getDefect_type());//缺陷类型代码
					itpd.setDefect_intensity(defe.getDefect_intensity());//缺陷级别（1：slight,、2：medium、3：heavy）
					this.getMapper(IfRoll01L2PdoDfcMapper.class).insert(itpd);
					i++;
				}
			}
		}catch(Exception ex){
			ex.printStackTrace();
		}
			
		//道次信息处理
		//道次信息处理
	  try{
		  List<IfRoll01L2PdoPass> rcm_data = v_rec_l2_pdo.getRcm_data();
		  for(IfRoll01L2PdoPass pdo_pass:rcm_data){
			  if(pdo_pass.getCurr_pass_no()==null || "".equals(pdo_pass.getCurr_pass_no().trim())){
				  continue;
			  }
			  pdo_pass.setSerial_no(max_serial_no);
			  pdo_pass.setExit_coil_no(v_rec_l2_pdo.getExit_coil_no());
			  this.getMapper(IfRoll01L2PdoPassMapper.class).insert(pdo_pass);
		  }
	  }catch(Exception e){
		  
	  }
			
		//  --(2)、调用L2钢卷生产实绩处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2Pdo_d(v_mch_code,v_rec_l2_pdo,v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_pdo.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String v_param="消息时间 MSG_TIME {"+mes_time+"} 记录号 SERIAL_NO {"+v_rec_l2_pdo.getSerial_no()+"}";																																							
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2Pdo",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}
	
	/**
	 * 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Pdo 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_PDO（L2钢卷生产实绩电文对象）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_pdo
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2Pdo_d(String v_mch_code, IfRoll01L2Pdo v_rec_l2_pdo,
			String v_message) throws Exception{
		IfRoll01L3AnswerPdo v_rec_l3_asw_pdo=new IfRoll01L3AnswerPdo();
		Integer v_success=null;
		try{
			//  --(1)、调用 L2钢卷生产实绩 处理函数
			try{
				v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2Pdo_d_d(v_mch_code,v_rec_l2_pdo,
						v_success,v_message);
			}catch(Exception e){
				e.printStackTrace();
				v_message=e.getMessage();
			}
			//  --(1.1)、构造 L3应答L2钢卷生产实绩 电文																																							
			//  --(1.1.1)、L3处理L2钢卷生产实绩电文成功（1：成功）																																							
			if(v_message==null){
				v_message="";
			}
			String v_success_str="";
			if(v_message.contains("_success:")){
				v_success_str=v_message.substring(v_message.length()-1);
				v_message=v_message.substring(0, v_message.lastIndexOf("_success"));
			}
			if("1".equals(v_success_str)){
				v_rec_l3_asw_pdo.setResult("0");// --处理结果（0：成功、1：错误）
			}else{
				v_rec_l3_asw_pdo.setResult("1");//--处理标志（0：成功、1：不成功）
			}
			v_rec_l3_asw_pdo.setExit_coil_no(v_rec_l2_pdo.getExit_coil_no());//--入口钢卷号
			v_rec_l3_asw_pdo.setSend_time(new Date());
			v_rec_l3_asw_pdo.setSend_opr("L3");//--下发人
			//  --(2)、调用 L3应答L2钢卷生产实绩 处理函数
			String v_message2="";
			try{
				v_message2=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3AswPdo(v_rec_l3_asw_pdo,v_message2);
			}catch(Exception e){
				e.printStackTrace();
				v_message2=e.getMessage();
			}
			//  --(4)、拼接返回字符串
			String v_param = "下发时间 SEND_TIME {"+v_rec_l3_asw_pdo.getSend_time()+"} 下发人 SEND_OPR {"+ v_rec_l3_asw_pdo.getSend_opr()	+																																						
			             "} 出口卷号 EXIT_COIL_NO {"+v_rec_l3_asw_pdo.getExit_coil_no()+"} 处理结果（0：成功、1：错误） RESULT {"+
					v_rec_l3_asw_pdo.getResult()+"} 预留 RESERVE {"+v_rec_l3_asw_pdo.getReserve()+"}";																																							
			//  --(5)、写接口日志：与业务处理分开，单独的事务
			try{
				this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L3AswPdo",v_param,v_message2);
			}catch(Exception e){
				e.printStackTrace();
			}
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2Pdo_d处理出错："+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2Pdo_d处理出错："+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
		
	}
	

	/**
	 * 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Pdo_d 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_PDO（L2钢卷生产实绩电文对象）																																							
		3)、	接口参数 OUT：V_SUCCESS（操作成功标志（1：成功、0：失败））、V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_pdo
	 * @param v_success
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value="tm", rollbackFor=Exception.class)
	public String Roll01L2Pdo_d_d(String v_mch_code, IfRoll01L2Pdo v_rec_l2_pdo,
			Integer v_success, String v_message) throws Exception{
		Integer v_cnt=null;
		PlnRollingPlanDetail v_rec_pln_d=new PlnRollingPlanDetail();
		//--(0)、置输出参数：操作成功标志为0：失败
		v_success=0;
		try{
			//  --(1)、验证传入参数的基本有效性
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--(1.2.1)、获取机台基础信息表中，配置的机台设备代号（设备编号，如1,2,3）
			ComBaseMachine cbm = this.getMapper(ComBaseMachineMapper.class).findById(v_mch_code);
			if(cbm.getMachine_mark()==null){
				v_message="机台代码{"+v_mch_code+"} 设备编号未配置，无法处理！";
				return v_message;
			}
			//  --(1.3)、验证入口卷号不为空
			if(v_rec_l2_pdo.getEntry_coil_no()==null || "".equals(v_rec_l2_pdo.getEntry_coil_no())){
				v_message="入口卷号{"+v_rec_l2_pdo.getEntry_coil_no()+"} 未指定入口卷号！";
				return v_message;
			}
			if(v_rec_l2_pdo.getEntry_coil_no().substring(0, 1).equals("L")){
				List<YdmProductDetail> listypd = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "materailcoilno='"+v_rec_l2_pdo.getEntry_coil_no()+"'", "", 0, 0);
				if(listypd!=null && listypd.size()==1){
					v_rec_l2_pdo.setEntry_coil_no(listypd.get(0).getCoilno());
					if(v_rec_l2_pdo.getExit_coil_no()!=null){
						int ia=v_rec_l2_pdo.getExit_coil_no().length()-v_rec_l2_pdo.getEntry_coil_no().length();
						if(ia==1){
							String weihao = v_rec_l2_pdo.getExit_coil_no().substring(v_rec_l2_pdo.getExit_coil_no().length()-1, v_rec_l2_pdo.getExit_coil_no().length());
							v_rec_l2_pdo.setExit_coil_no(v_rec_l2_pdo.getEntry_coil_no()+weihao);
						}
					}
				}
			}
			
			
			
			//  --(2)、业务处理：																																							
			//  --(2.1)、验证电文中“开始生产时刻（YYYYMMDDHHMMSS）”																																							
			Date v_str_time=null;
			if(v_rec_l2_pdo.getStart_time()==null || "".equals(v_rec_l2_pdo.getStart_time())){
				v_str_time=new Date();//--如果开始生产时间为空，则赋值为当前时刻
			}else{
				//    --(2.1.1)、将开始生产时间的字符串，转换日期时间格式（可以在JAVA中转化，此处以PLSQL处理代替描述）
				try {
					List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(v_rec_l2_pdo.getStart_time());
					v_str_time=li.get(0).getCreate_time();
				} catch (Exception e) {
					e.printStackTrace();
					v_message="电文中“开始生产时间”{"+v_rec_l2_pdo.getStart_time()+"} 格式转化失败，无法计算日期班次！约定的标准格式【yyyyMMddHHmmss】";
					return v_message;
				}
			}
			// --(2.1')、验证电文中“结束生产时刻（YYYYMMDDHHMMSS）”
			Date v_end_time=null;
			if(v_rec_l2_pdo.getEnd_time()==null || "".equals(v_rec_l2_pdo.getEnd_time())){
				v_end_time=new Date();//--如果开始结束时间为空，则赋值为当前时刻
			}else{
				//  --(2.1.1)、将结束生产时间的字符串，转换日期时间格式（可以在JAVA中转化，此处以PLSQL处理代替描述）
				try {
					List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(v_rec_l2_pdo.getEnd_time());
					v_end_time=li.get(0).getCreate_time();
				} catch (Exception e) {
					e.printStackTrace();
					//v_message="电文中“开始生产时间”{"+v_rec_l2_pdo.getEnd_time()+"} 格式转化失败，无法计算日期班次！约定的标准格式【yyyyMMddHHmmss】";
					//return v_message;
					//--(2.1.2')、转化失败（非约定的标准格式：YYYYMMDDHHmmss）：则赋值为当前时刻
					v_end_time=new Date();
				}
			}
			String rmDb=DateUtil.formatDate(v_str_time, "yyyy-MM-dd HH:mm:ss");
			String v_date=null,v_ord=null;
			String dbTime=rmDb.substring(11);
			v_date=rmDb.substring(0,10);
			// --(1.1.1)、如果 v_charge_time 的时间>=00:00:00并且<08:00:00，则 作业日期 = v_charge_time 的日期（格式化为yyyy-MM-dd），班次 = "1"，即表示当天晚班；
			if(dbTime.compareTo(DateUtil.NBeginTime)>-1&&dbTime.compareTo(DateUtil.BeginTime)<0){
				v_ord="1";
			}else if(dbTime.compareTo(DateUtil.BeginTime)>-1&&dbTime.compareTo(DateUtil.EndTime)<0){
				v_ord="2";
			}else if(dbTime.compareTo(DateUtil.EndTime)>-1&&dbTime.compareTo(DateUtil.NEndTime)<0){
				v_ord="1";
				SimpleDateFormat formatYmd = new SimpleDateFormat("yyyy-MM-dd");
				Date date;
				try {
					date = formatYmd.parse(v_date);
				} catch (Exception e) {
					return "获取数据库时间失败，请稍后重试";
				}
				Calendar c = Calendar.getInstance();  
		        c.setTime(date);  
		        c.add(Calendar.DAY_OF_MONTH, 1);//日期+1 
		        v_date=formatYmd.format(c.getTime());
			}
			//  --(2)、验证业务数据合理性																																							
			//  --(2.3)、根据计算的日期班次，获取交接班记录的班组																																				
			MesShiftM msm=new MesShiftM();
			msm.setMachine_code(v_mch_code);
			msm.setWrk_date(v_date);
			msm.setWrk_ord(v_ord);
			v_cnt=this.getMapper(MesShiftMMapper.class).count(msm);
			String v_grp=null;
			if(v_cnt<=0){
				v_grp="";// --无交接班记录，则赋空值（交工时，会提示用户完善信息）
			}else{
				//    --否则获取交接班记录中的班组
				List<MesShiftM> lmsm = this.getMapper(MesShiftMMapper.class).find(msm, 0, 0);
				v_grp=lmsm.get(0).getWrk_grp();
			}
			//  --(2.4)、验证入口卷对应的作业计划信息存在  
			v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount1(v_mch_code,v_rec_l2_pdo.getEntry_coil_no());
			if(v_cnt<=0){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_rec_l2_pdo.getEntry_coil_no()+"} 找不到作业计划信息！";
				return v_message;  
			}else if(v_cnt>1){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_rec_l2_pdo.getEntry_coil_no()+"}存在2条或以上的作业计划信息！";
				return v_message; 
			}else{
				List<PlnRollingPlanDetail> v_rec_pln_d_list=this.getMapper(PlnRollingPlanDetailMapper.class).doQuery3(v_mch_code, v_rec_l2_pdo.getEntry_coil_no());
				v_rec_pln_d=v_rec_pln_d_list.get(0);
			}
			//  --(2.5)、如果已有生产实绩（人工操作或L2重复发送PDO情况下），且已交工，则返回（忽略此电文事件）
			MesRcmM mCross = new MesRcmM();
			mCross.setSchedule_no(v_rec_pln_d.getRl_plan_no());
			mCross.setMaterial_no(v_rec_l2_pdo.getEntry_coil_no());
			v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
			MesRcmM v_rec_Roll_m=new MesRcmM();
			boolean flag=false;//
			if(v_cnt>0){
				List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
			    v_rec_Roll_m =lmcam.get(0);
			    flag=true;
			    if("1".equals(v_rec_Roll_m.getHand_over_status())){
			    	v_message = "机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} "
			    			+ "入口卷号{"+v_rec_l2_pdo.getEntry_coil_no()+"} 已生产交工，忽略此电文事件！'";
					return v_message;
			    }
			}
			//  --(2.6)、验证虚拟物料表中，原料卷计划信息存在
			List<PlnMaterielDetail> v_rec_mtr_in_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_in_list==null || v_rec_mtr_in_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_pdo.getEntry_coil_no()+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+"} 原料卷虚拟物料信息不存在！";																																							
				return v_message;
			}
			PlnMaterielDetail v_rec_mtr_in=v_rec_mtr_in_list.get(0);
			//  --(2.7)、验证原料卷号库存明细记录存在
			List<YdmProductDetail> v_rec_ydm_d_list = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "coilno='"+v_rec_l2_pdo.getEntry_coil_no()+"'", null, 0, 0);
			if(v_rec_ydm_d_list==null || v_rec_ydm_d_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_pdo.getEntry_coil_no()+"} 原料卷库存明细记录不存在！";
				return v_message;
			}
			YdmProductDetail v_rec_ydm_d=  v_rec_ydm_d_list.get(0);
			//  --(2.8)、验证虚拟物料表中，出口卷虚拟物料信息存在
			List<PlnMaterielDetail> v_rec_mtr_out_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"mat_object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_out_list==null || v_rec_mtr_out_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_pdo.getEntry_coil_no()+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+" 出口卷虚拟物料信息不存在！";
				return v_message;
			}
			
			//2018-11-29 只有是已下发状态的钢卷才能下发
			if(v_rec_pln_d!=null){
				if(!("5BRL02".equals(v_rec_pln_d.getStatus()) || "5BRL03".equals(v_rec_pln_d.getStatus()))){
					v_message="当前状态{"+v_rec_pln_d.getStatus()+"}错误";
					return v_message;
				}
			}
			
			/*
			 * 2019-03-08断带情况、正常分卷的处理
			 * */
			if(v_rec_l2_pdo.getExit_coil_no()!=null && v_rec_l2_pdo.getExit_coil_no().length()>3 &&
					!"1".equals(v_rec_l2_pdo.getExit_coil_no().substring(v_rec_l2_pdo.getExit_coil_no().length()-1, 
							v_rec_l2_pdo.getExit_coil_no().length()))){
				int i=v_rec_l2_pdo.getExit_coil_no().length()-v_rec_l2_pdo.getEntry_coil_no().length();
				String subtri = v_rec_l2_pdo.getExit_coil_no().substring(v_rec_l2_pdo.getExit_coil_no().length()-1, 
						v_rec_l2_pdo.getExit_coil_no().length());
				long abc2=0;
				try{
					abc2 = Long.valueOf(subtri);
				}catch(Exception e){
					
				}
				if(i==1 && abc2>1){
				//  --(1)、出现断带情况，调用 L2钢卷出口卷2,3,4，xx
					try{
						v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2Pdo_d_d_234(v_mch_code,v_rec_l2_pdo,v_rec_Roll_m,
								v_success,v_message);
					}catch(Exception e){
						e.printStackTrace();
						v_message=e.getMessage();
					}
					return v_message;
				}
			    
			}
			
			
			//  --(2.9.2)、出口卷编码规则：出口卷编码前缀【原料卷号（最初始原料卷号） + 1位工序代号（平整P）+ 2位设备代号（01-99）】+ 2位流水（01 - 99）																																					
			//v_coil_no=v_coil_no+lpad(v_cnt+"",2,"0");
			//  --(2.11)、在 v_rec_Roll_m 对象基础上，构建平整主实绩，并插入记录																																							
			//  --(2.11.1)：v_rec_Roll_m 对象可能不为空（之前实绩已存在），则更新部分信息，保留部分信息（未赋值的属性即是保留原有对象的属性值）																																							
			//  --(2.11.2)：v_rec_Roll_m 对象如果为空，请先实例化此对象（plsql示例逻辑无此问题）				
			ComBaseMachine machine2 = new ComBaseMachine();
			machine2.setMachine_code(v_mch_code);
			List<ComBaseMachine> lcbm = this.getMapper(ComBaseMachineMapper.class)
					.find(machine2, 0, 0);
			String v_mch_mark=lcbm.get(0).getMachine_mark();
			if (v_mch_mark == null) {
				return "机台代码：" +v_mch_code+ "\n设备编号未配置，无法处理！";
			}
			String v_process_no="";
			if(!flag){//如果 v_rec_plm_m 对象为空（即之前无生产实绩）
				SimpleDateFormat formatY3 = new SimpleDateFormat("yyMMdd");
				v_process_no = "Z" + formatY3.format(new Date())+lpad(v_mch_mark, 2, "0");
				v_cnt = this.getMapper(MesRcmMMapper.class).doquery(v_process_no);
				if (v_cnt == null) {
					v_cnt = 1;
				}
				v_process_no = v_process_no + lpad(v_cnt.toString(), 3, "0");
				v_rec_Roll_m.setProcess_no(v_process_no);
			}
			
			
			
			  v_rec_Roll_m.setMachine_code    ( v_mch_code);// --机台号（区分厂家：艾伯纳、中冶南方、宝信）																																							
			  v_rec_Roll_m.setSchedule_no     ( v_rec_pln_d.getRl_plan_no());// --作业计划号																																							
			  v_rec_Roll_m.setInner_seq       ( v_rec_pln_d.getRl_seq());// --计划内序号																																							
			  v_rec_Roll_m.setMaterial_no_vt  ( v_rec_pln_d.getObject_no_vt());// --虚拟原料卷号																																							
			  v_rec_Roll_m.setPln_steel_code  ( v_rec_mtr_in.getSteel_code());// --计划原料卷牌号																																							
			  v_rec_Roll_m.setPln_mtr_thk     ( v_rec_mtr_in.getThick());// --计划原料卷厚度																																							
			  v_rec_Roll_m.setPln_mtr_wdt     ( v_rec_mtr_in.getWidth());// --计划原料卷宽度																																							
			  v_rec_Roll_m.setPln_mtr_len     ( v_rec_mtr_in.getLength());// --计划原料卷长度																																							
			  v_rec_Roll_m.setPln_mtr_inn_dia ( v_rec_mtr_in.getDiameter_inn());// --计划原料卷内径																																							
			  v_rec_Roll_m.setPln_mtr_out_dia ( v_rec_mtr_in.getDiameter_out());// --计划原料卷外径																																							
			  v_rec_Roll_m.setPln_mtr_thr_wgt ( v_rec_mtr_in.getSingle_weight());// --计划原料卷理重																																							
			  v_rec_Roll_m.setMaterial_no     ( v_rec_l2_pdo.getEntry_coil_no());// --原料卷号																																							
			  v_rec_Roll_m.setMaterial_no_src ( v_rec_ydm_d.getMaterailcoilno());// --原始卷号																																							
			  v_rec_Roll_m.setMtr_thk         ( v_rec_ydm_d.getThick());// --原料卷厚度																																							
			  v_rec_Roll_m.setMtr_wdt         ( v_rec_ydm_d.getWidth());// --原料卷宽度																																							
			  v_rec_Roll_m.setMtr_len         ( v_rec_ydm_d.getLength());// --原料卷长度																																							
			  v_rec_Roll_m.setMtr_inn_dia     ( v_rec_ydm_d.getDiameter_inn());// --原料卷内径																																							
			  v_rec_Roll_m.setMtr_out_dia     ( v_rec_ydm_d.getDiameter_out());// --原料卷外径																																							
			  if(v_rec_ydm_d.getTheoryweight()!=null){
				  v_rec_Roll_m.setMtr_thr_wgt     ( v_rec_ydm_d.getTheoryweight());// --原料卷理重	
			  }else{
				  v_rec_Roll_m.setMtr_thr_wgt     (v_rec_ydm_d.getFactweight());// --原料卷理重	
			  }																																					
			  v_rec_Roll_m.setMtr_act_wgt     ( v_rec_ydm_d.getFactweight());// --原料卷实重																																							
			  v_rec_Roll_m.setSteel_code      ( v_rec_ydm_d.getSteelcode());// --原料卷牌号
			  
			  if(!flag){//如果 v_rec_Roll_m 对象为空（即之前无生产实绩），则覆盖 作业日期、班次、班组（与生产开始不同，请注意）
				  v_rec_Roll_m.setWrk_date     ( v_date);// --作业日期（YYYY-MM-DD）																																							
				  v_rec_Roll_m.setWrk_ord      ( v_ord); //--作业班次（0常白班、1晚班、2白班、3中班）																																							
				  v_rec_Roll_m.setWrk_grp      ( v_grp);// --作业班组（0常白班、1甲班、2乙班、3丙班、4丁班）																																							
				  v_rec_Roll_m.setFeeding_time ( v_str_time); //--上料时间		
			  }
			  if(v_rec_l2_pdo.getStrip_break()!=null){
				  v_rec_Roll_m.setStrip_break(v_rec_l2_pdo.getStrip_break()+""); //--是否断带（1：断带、0：正常）
			  }
			  
			  v_rec_Roll_m.setTp_str_time(v_str_time); //--生产开始时间
			  v_rec_Roll_m.setTp_end_time(v_end_time); 
			  //--生产时间（min）
			  if(v_rec_l2_pdo.getDuration()==null || "".equals(v_rec_l2_pdo.getDuration())){
				  v_rec_Roll_m.setTp_duration(null);
			  }else{
				  try{
					  v_rec_Roll_m.setTp_duration(Long.parseLong(v_rec_l2_pdo.getDuration()));
				  }catch(Exception e){
					  //v_rec_Roll_m.setTp_duration(null);
				  }
			  }
			  try{
				  v_rec_Roll_m.setExit_thickness_set  ( strToLong(v_rec_l2_pdo.getExit_thickness_setp()));// --1#机架出口卷厚度设定值（um）																																							
				  v_rec_Roll_m.setExit_thickness_avg  ( strToLong(v_rec_l2_pdo.getExit_thickness_avg()));// --1#机架出口卷厚度平均值（um）																																							
				  v_rec_Roll_m.setExit_thickness_max  ( strToLong(v_rec_l2_pdo.getExit_thickness_max()));// --1#机架出口卷厚度最大值（um）																																							
				  v_rec_Roll_m.setExit_thickness_min  ( strToLong(v_rec_l2_pdo.getExit_thickness_min()));// --1#机架出口卷厚度最小值（um）																																							
				  v_rec_Roll_m.setExit_thickness_deta ( strToLong(v_rec_l2_pdo.getExit_thickness_delta()));// --1#机架出口卷厚度方差（um）																																							
				  v_rec_Roll_m.setThickness_class_1   ( strToLong(v_rec_l2_pdo.getThickness_class_1()));// --<±1%公差（10^-2%）																																							
				  v_rec_Roll_m.setThickness_class_2   ( strToLong(v_rec_l2_pdo.getThickness_class_2()));// --<±2%公差（10^-2%）																																							
				  v_rec_Roll_m.setThickness_class_3   ( strToLong(v_rec_l2_pdo.getThickness_class_3()));// --<±4%公差（10^-2%）																																							
				  v_rec_Roll_m.setThickness_class_4   ( strToLong(v_rec_l2_pdo.getThickness_class_4()));// --<±6%公差（10^-2%）																																							
				  v_rec_Roll_m.setThickness_class_5   ( strToLong(v_rec_l2_pdo.getThickness_class_5()));// --<±10%公差（10^-2%）																																							
				  v_rec_Roll_m.setThickness_class_6   ( strToLong(v_rec_l2_pdo.getThickness_class_6()));// -->±10%公差（10^-2%）
				  
				  v_rec_Roll_m.setNum_defects         ( strToLong(v_rec_l2_pdo.getNum_defects()));// --缺陷个数
			  }catch(Exception e){
				  e.printStackTrace();
			  }
			  			
			  
			  //v_rec_Roll_m.setFeeding_wgt         ( v_rec_l2_pdo.getEntry_weight()==null?null:v_rec_l2_pdo.getEntry_weight().doubleValue());// --入口重量（kg）
			  v_rec_Roll_m.setFeeding_wgt         ( v_rec_ydm_d.getFactweight());// --入口重量（kg）
//			  if(v_rec_l2_pdo.getSpm_mode()!=null){
//				  v_rec_Roll_m.setSpm_mode            ( v_rec_l2_pdo.getSpm_mode()+"");// --平整模式	
//			  }
			  //v_rec_Roll_m.setMemo             ( null);// --备注																																							
			  v_rec_Roll_m.setHand_over_status ( "0");// --交工状态																																							
			  v_rec_Roll_m.setHand_over_time   ( null);// --交工时间																																							
			  v_rec_Roll_m.setHand_over_opr    ( null);// --交工人																																							

			  if(!flag){
				  //  --如果 v_rec_Roll_m 对象为空（即之前无生产实绩），则：
				  v_rec_Roll_m.setCreate_opr( "L2_DR3E08");// --操作人																																							
				  v_rec_Roll_m.setCreate_time( new Date());// --操作时间																																							
			  }else{
				  //  --如果 v_rec_Roll_m 对象不为空（即之前存在生产实绩），则（创建人、创建时间保留原值）：
				  v_rec_Roll_m.setUpdate_opr("L2_DR3E08");// --修改人																																							
				  v_rec_Roll_m.setUpdate_time(new Date()) ;//--修改时间																																							
			  }
			  
			  //--(2.12)、开始事物																																					
			  //--(2.12.0)、删除可能存在的平整作业实绩记录
			  this.getMapper(MesRcmMMapper.class).doDelete1(v_rec_pln_d.getRl_plan_no(),v_rec_l2_pdo.getEntry_coil_no());
			  //  --(3.2)、插入平整作业实绩记录
			  this.getMapper(MesRcmMMapper.class).insert(v_rec_Roll_m);
			  
			  
			  MesRcmD mtd=new MesRcmD();
			  mtd.setProcess_no(v_rec_Roll_m.getProcess_no());
		      List<MesRcmD> list = this.getMapper(MesRcmDMapper.class).find(mtd, 0, 0);
			  if(list==null || list.size()<=0){
				  ResultModel doAddsWebRm=new ResultModel();
				  try{
					  doAddsWebRm = this.getBean(MesRcmDServiceImpl.class).doAddsWeb_PDO(v_rec_pln_d.getRl_plan_no(), v_rec_pln_d.getObject_no_vt(),v_rec_pln_d.getObject_no(),"M0008","Roll01L2Pdo_d");
					  if("200".equals(doAddsWebRm.getState())){//子卷新增成功
						  List<MesRcmD> list_mtd = this.getMapper(MesRcmDMapper.class).findWithCondition(mtd, "", "coil_no", 0, 0);
						  if(list_mtd!=null && list_mtd.size()>0){
							  MesRcmD mtd0=list_mtd.get(0);
							  MesRcmD mtd0_new=new MesRcmD();
							  mtd0_new.setCoil_no(mtd0.getCoil_no());
							  mtd0_new.setAct_thk      ( v_rec_l2_pdo.getExit_thick()==null?null:strToLong(v_rec_l2_pdo.getExit_thick()).doubleValue()/1000);// --产出卷厚度um	
							  mtd0_new.setAct_len      ( v_rec_l2_pdo.getExit_length()==null?null:strToLong(v_rec_l2_pdo.getExit_length()).doubleValue()*1000);// --产出卷长度(m)																																							
							  mtd0_new.setAct_inn_dia  ( v_rec_l2_pdo.getInner_diameter()==null?null:strToLong(v_rec_l2_pdo.getInner_diameter()).doubleValue());// --产出卷内径																																							
							  mtd0_new.setAct_out_dia  ( v_rec_l2_pdo.getOuter_diameter()==null?null:strToLong(v_rec_l2_pdo.getOuter_diameter()).doubleValue());// --产出卷外径																																							
							  //mtd0_new.setCoil_thr_wgt ( v_rec_l2_pdo.getExit_calc_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_calc_weight()).doubleValue());// --产出卷理重	
							  mtd0_new.setCoil_thr_wgt ( v_rec_l2_pdo.getExit_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_weight()).doubleValue());// --产出卷理重	
							  mtd0_new.setCoil_act_wgt ( v_rec_l2_pdo.getExit_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_weight()).doubleValue());// --产出卷实量	
							  mtd0_new.setCoil_wgt_time(new Date());//出口卷称重时间
							  if(v_rec_l2_pdo.getExit_width()!=null){
								  mtd0_new.setAct_wdt(
										  v_rec_l2_pdo.getExit_width()==null?null:strToDouble(v_rec_l2_pdo.getExit_width()).doubleValue());
							  }
							  this.getMapper(MesRcmDMapper.class).update(mtd0_new);
							  
							//道次信息处理
							  try{
								  List<IfRoll01L2PdoPass> rcm_data = v_rec_l2_pdo.getRcm_data();
								  this.getMapper(MesRcmDPassMapper.class).doDelete(v_rec_Roll_m.getProcess_no(),mtd0.getCoil_no());
								  for(IfRoll01L2PdoPass pdo_pass:rcm_data){
									  if(pdo_pass.getCurr_pass_no()==null || "".equals(pdo_pass.getCurr_pass_no().trim())){
										  continue;
									  }
									  MesRcmDPass mrdp=new MesRcmDPass();
									  Date v_time=null;
									  try {
											List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(pdo_pass.getPass_start_time());
											v_time=li.get(0).getCreate_time();
											mrdp.setPass_start_time(v_time);
											List<MesCrAnnealM> li2 =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(pdo_pass.getPass_end_time());
											v_time=li2.get(0).getCreate_time();
											mrdp.setPass_end_time(v_time);
											mrdp.setCoil_no(mtd0.getCoil_no());
											mrdp.setCurr_pass_no(pdo_pass.getCurr_pass_no());
											mrdp.setEntry_tension_avg(strToDouble(pdo_pass.getEntry_tension_avg())==null?"":(strToDouble(pdo_pass.getEntry_tension_avg())+""));
											mrdp.setEntry_tension_max(strToDouble(pdo_pass.getEntry_tension_max())==null?"":(strToDouble(pdo_pass.getEntry_tension_max())+""));
											mrdp.setEntry_tension_min(strToDouble(pdo_pass.getEntry_tension_min())==null?"":(strToDouble(pdo_pass.getEntry_tension_min())+""));
											mrdp.setExit_tension_avg(strToDouble(pdo_pass.getExit_tension_avg())==null?"":(strToDouble(pdo_pass.getExit_tension_avg())+""));
											mrdp.setExit_tension_max(strToDouble(pdo_pass.getExit_tension_max())==null?"":(strToDouble(pdo_pass.getExit_tension_max())+""));
											mrdp.setExit_tension_min(strToDouble(pdo_pass.getExit_tension_min())==null?"":(strToDouble(pdo_pass.getExit_tension_min())+""));
											mrdp.setImr_bending_force(strToDouble(pdo_pass.getImr_bending_force())==null?"":(strToDouble(pdo_pass.getImr_bending_force())+""));
											mrdp.setMill_force(strToDouble(pdo_pass.getMill_force())==null?"":(strToDouble(pdo_pass.getMill_force())+""));
											mrdp.setMill_force_deta(strToDouble(pdo_pass.getMill_force_deta())==null?"":(strToDouble(pdo_pass.getMill_force_deta())+""));
											mrdp.setMill_speed(strToDouble(pdo_pass.getMill_speed())==null?"":(strToDouble(pdo_pass.getMill_speed())+""));
											mrdp.setMsg_time(new Date());
											mrdp.setPass_duration(strToDouble(pdo_pass.getPass_duration())==null?"":(strToDouble(pdo_pass.getPass_duration())+""));
											mrdp.setPass_entry_thick(strToDouble(pdo_pass.getPass_entry_thick())==null?"":(strToDouble(pdo_pass.getPass_entry_thick())+""));
											mrdp.setPass_exit_thick(strToDouble(pdo_pass.getPass_exit_thick())==null?"":(strToDouble(pdo_pass.getPass_exit_thick())+""));
											mrdp.setProcess_no(v_rec_Roll_m.getProcess_no());
											mrdp.setReduction(strToDouble(pdo_pass.getReduction())==null?"":(strToDouble(pdo_pass.getReduction())+""));
											mrdp.setShift_pos(strToDouble(pdo_pass.getShift_pos())==null?"":(strToDouble(pdo_pass.getShift_pos())+""));
											mrdp.setSpindle_torque(strToDouble(pdo_pass.getSpindle_torque())==null?"":(strToDouble(pdo_pass.getSpindle_torque())+""));
											mrdp.setWkr_bending_force(strToDouble(pdo_pass.getWkr_bending_force())==null?"":(strToDouble(pdo_pass.getWkr_bending_force())+""));
											this.getMapper(MesRcmDPassMapper.class).insert(mrdp);
										} catch (Exception e) {
											e.printStackTrace();
										}
								  }
							  }catch(Exception e){
								  e.printStackTrace();
							  }
							  
						  }
					  }else{
						  throw new Exception("生产实绩调用批量新增子卷接口报错");
					  }
				  }catch(Exception e){
					  e.printStackTrace();
					  v_message=e.getMessage();
					  throw new Exception("生产实绩调用批量新增子卷接口报错"+v_message);
				  }
					  
			  }else{//之前就存在子卷实绩
				  List<MesRcmD> list_mtd = this.getMapper(MesRcmDMapper.class).findWithCondition(mtd, "substr(coil_no, -1) <> 'B'", "coil_no", 0, 0);
				  if(list_mtd!=null && list_mtd.size()>0){
					  MesRcmD mtd0=list_mtd.get(0);
					  MesRcmD mtd0_new=new MesRcmD();
					  mtd0_new.setCoil_no(mtd0.getCoil_no());
					  mtd0_new.setAct_thk      ( v_rec_l2_pdo.getExit_thick()==null?null:strToLong(v_rec_l2_pdo.getExit_thick()).doubleValue()/1000);// --产出卷厚度um	
					  mtd0_new.setAct_len      ( v_rec_l2_pdo.getExit_length()==null?null:strToLong(v_rec_l2_pdo.getExit_length()).doubleValue()*1000);// --产出卷长度(m)																																							
					  mtd0_new.setAct_inn_dia  ( v_rec_l2_pdo.getInner_diameter()==null?null:strToLong(v_rec_l2_pdo.getInner_diameter()).doubleValue());// --产出卷内径																																							
					  mtd0_new.setAct_out_dia  ( v_rec_l2_pdo.getOuter_diameter()==null?null:strToLong(v_rec_l2_pdo.getOuter_diameter()).doubleValue());// --产出卷外径																																							
					  //mtd0_new.setCoil_thr_wgt ( v_rec_l2_pdo.getExit_calc_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_calc_weight()).doubleValue());// --产出卷理重
					  mtd0_new.setCoil_thr_wgt ( v_rec_l2_pdo.getExit_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_weight()).doubleValue());// --产出卷理重
					  mtd0_new.setCoil_act_wgt ( v_rec_l2_pdo.getExit_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_weight()).doubleValue());// --产出卷实量	
					  mtd0_new.setCoil_wgt_time(new Date());//出口卷称重时间
					  if(v_rec_l2_pdo.getExit_width()!=null){
						  mtd0_new.setAct_wdt(
								  v_rec_l2_pdo.getExit_width()==null?null:strToDouble(v_rec_l2_pdo.getExit_width()).doubleValue());
					  }
					  this.getMapper(MesRcmDMapper.class).update(mtd0_new);
					  
					//道次信息处理
					  try{
						  List<IfRoll01L2PdoPass> rcm_data = v_rec_l2_pdo.getRcm_data();
						  this.getMapper(MesRcmDPassMapper.class).doDelete(v_rec_Roll_m.getProcess_no(),mtd0.getCoil_no());
						  for(IfRoll01L2PdoPass pdo_pass:rcm_data){
							  if(pdo_pass.getCurr_pass_no()==null || "".equals(pdo_pass.getCurr_pass_no().trim())){
								  continue;
							  }
							  MesRcmDPass mrdp=new MesRcmDPass();
							  Date v_time=null;
							  try {
									List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(pdo_pass.getPass_start_time());
									v_time=li.get(0).getCreate_time();
									mrdp.setPass_start_time(v_time);
									List<MesCrAnnealM> li2 =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(pdo_pass.getPass_end_time());
									v_time=li2.get(0).getCreate_time();
									mrdp.setPass_end_time(v_time);
									mrdp.setCoil_no(mtd0.getCoil_no());
									mrdp.setCurr_pass_no(pdo_pass.getCurr_pass_no());
									mrdp.setEntry_tension_avg(strToDouble(pdo_pass.getEntry_tension_avg())==null?"":(strToDouble(pdo_pass.getEntry_tension_avg())+""));
									mrdp.setEntry_tension_max(strToDouble(pdo_pass.getEntry_tension_max())==null?"":(strToDouble(pdo_pass.getEntry_tension_max())+""));
									mrdp.setEntry_tension_min(strToDouble(pdo_pass.getEntry_tension_min())==null?"":(strToDouble(pdo_pass.getEntry_tension_min())+""));
									mrdp.setExit_tension_avg(strToDouble(pdo_pass.getExit_tension_avg())==null?"":(strToDouble(pdo_pass.getExit_tension_avg())+""));
									mrdp.setExit_tension_max(strToDouble(pdo_pass.getExit_tension_max())==null?"":(strToDouble(pdo_pass.getExit_tension_max())+""));
									mrdp.setExit_tension_min(strToDouble(pdo_pass.getExit_tension_min())==null?"":(strToDouble(pdo_pass.getExit_tension_min())+""));
									mrdp.setImr_bending_force(strToDouble(pdo_pass.getImr_bending_force())==null?"":(strToDouble(pdo_pass.getImr_bending_force())+""));
									mrdp.setMill_force(strToDouble(pdo_pass.getMill_force())==null?"":(strToDouble(pdo_pass.getMill_force())+""));
									mrdp.setMill_force_deta(strToDouble(pdo_pass.getMill_force_deta())==null?"":(strToDouble(pdo_pass.getMill_force_deta())+""));
									mrdp.setMill_speed(strToDouble(pdo_pass.getMill_speed())==null?"":(strToDouble(pdo_pass.getMill_speed())+""));
									mrdp.setMsg_time(new Date());
									mrdp.setPass_duration(strToDouble(pdo_pass.getPass_duration())==null?"":(strToDouble(pdo_pass.getPass_duration())+""));
									mrdp.setPass_entry_thick(strToDouble(pdo_pass.getPass_entry_thick())==null?"":(strToDouble(pdo_pass.getPass_entry_thick())+""));
									mrdp.setPass_exit_thick(strToDouble(pdo_pass.getPass_exit_thick())==null?"":(strToDouble(pdo_pass.getPass_exit_thick())+""));
									mrdp.setProcess_no(v_rec_Roll_m.getProcess_no());
									mrdp.setReduction(strToDouble(pdo_pass.getReduction())==null?"":(strToDouble(pdo_pass.getReduction())+""));
									mrdp.setShift_pos(strToDouble(pdo_pass.getShift_pos())==null?"":(strToDouble(pdo_pass.getShift_pos())+""));
									mrdp.setSpindle_torque(strToDouble(pdo_pass.getSpindle_torque())==null?"":(strToDouble(pdo_pass.getSpindle_torque())+""));
									mrdp.setWkr_bending_force(strToDouble(pdo_pass.getWkr_bending_force())==null?"":(strToDouble(pdo_pass.getWkr_bending_force())+""));
									this.getMapper(MesRcmDPassMapper.class).insert(mrdp);
								} catch (Exception e) {
									e.printStackTrace();
								}
						  }
					  }catch(Exception e){
						  e.printStackTrace();
					  }
					  
				  }
			  }
			  
			  
			  
			  
			  //--(3.3)、调用生产管理接口，执行业计划状态、物料进程状态相关操作（接口由生产管理模块提供）；；																																							
			  //--(3.3.1)、注意：可能在收到此PDO前，已执行过上料操作，并进行了此接口的操作，要求能正常处理，不能影响上述操作																																							
																																										
			  //--(3.4)、调用物流模块接口，执行原料卷生产投料出库相关操作（接口由物流模块提供）；																																							
			  //--(3.4.1)、注意：可能在收到此PDO前，已执行过上料操作，原料卷可能已投料出库，此时不能影响上述操作																																							
				MesRcmM  mcsm=new MesRcmM();
				mcsm.setMachine_code(v_mch_code);//机台号
				mcsm.setSchedule_no(v_rec_pln_d.getRl_plan_no());//作业计划号
				mcsm.setMaterial_no(v_rec_l2_pdo.getEntry_coil_no());//投料卷号
				mcsm.setMaterial_no_vt(v_rec_pln_d.getObject_no_vt());//虚拟卷号 
				List<MesRcmM> lmcsm=new ArrayList<MesRcmM>();
				//时间
				SimpleDateFormat dfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");//设置日期格式
			    String date = dfs.format(new Date());// new Date()为获取当前系统时间，也可使用当前时间戳
			    mcsm.setMemo(date);
			    lmcsm.add(mcsm);
			   //调用生产管理接口验证作业计划状态能执行此操作
				boolean flag2=true;
				try{
					this.getBean(MesApiRollingPlanImpl.class).MesRcmMAddValid(lmcsm);
				}catch(Exception e){
					flag2=false;
					e.printStackTrace();
				}
				if(flag2){
					//调用生产管理接口，更改业计划状态（主表、从表）、原料虚拟物料进程状态
					this.getBean(MesApiRollingPlanImpl.class).MesRcmMAdd(lmcsm);
				}
				
				//调用物流模块（仓库管理）接口，对原料卷进行生产投料出库操作（接口由物流模块提供）；
				YdmProductOutlist ypo=new YdmProductOutlist();
				ypo.setCoilno(v_rec_l2_pdo.getEntry_coil_no());
				ypo.setOuttype("500501");
				v_cnt = this.getMapper(YdmProductOutlistMapper.class).count(ypo);
				if(v_cnt<=0){
					CommonPage<YdmProductDetail> cp2=new CommonPage<YdmProductDetail>();
					YdmProductDetail ypdu=new YdmProductDetail();
					ypdu.setCoilno(v_rec_l2_pdo.getEntry_coil_no());//注意
					// 传入操作时间字符串带毫秒
					ypdu.setMemo(date);
					cp2.setObject(ypdu);
					this.getBean(LmsApiServiceImpl.class).doOutStorage(cp2);
				}
			//--唯一置为成功的地方	
			v_success=1;	
			v_message = "Roll01L2Pdo L2钢卷生产实绩电文处理成功！"+"_success:"+v_success;  
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2Pdo L2钢卷生产实绩电文处理失败！"+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2Pdo L2钢卷生产实绩电文处理失败！"+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}

	//断带的情况、正常分卷的情况
	@Transactional(propagation = Propagation.REQUIRES_NEW,value="tm", rollbackFor=Exception.class)
	public String Roll01L2Pdo_d_d_234(String v_mch_code, IfRoll01L2Pdo v_rec_l2_pdo,
			MesRcmM v_rec_Roll_m, Integer v_success, String v_message) throws Exception{
		String seqcount="";
		try{
			seqcount = v_rec_l2_pdo.getExit_coil_no().substring(v_rec_l2_pdo.getExit_coil_no().length()-1, 
					v_rec_l2_pdo.getExit_coil_no().length());
			
			if(v_rec_Roll_m==null || v_rec_Roll_m.getMaterial_no()==null || v_rec_Roll_m.getSchedule_no()==null){
				v_message="此电文处理产出卷{"+seqcount+"}，"+"还未存在实绩信息";
				return v_message;
			}
			MesRcmM mtm=new MesRcmM();
			mtm.setMaterial_no(v_rec_Roll_m.getMaterial_no());
			mtm.setSchedule_no(v_rec_Roll_m.getSchedule_no());
			List<MesRcmM> list = this.getMapper(MesRcmMMapper.class).find(mtm, 0, 0);
			if(list==null || list.size()<=0){
				v_message="此电文处理产出卷{"+seqcount+"}，"+"还未存在实绩信息";
				return v_message;
			}
			MesRcmM MesRcmM = list.get(0);
			
			
			MesRcmD mtd=new MesRcmD();
			mtd.setProcess_no(MesRcmM.getProcess_no());
			List<MesRcmD> list_mtd = this.getMapper(MesRcmDMapper.class).findWithCondition(mtd, "substr(coil_no, -1) <> 'B'", "coil_no", 0, 0);
			if(list_mtd==null || list_mtd.size()<=0){
				  	v_message="此电文处理产出卷{"+seqcount+"}，"+"还未存在第一个出口卷";
					return v_message;  
			}else{//之前就存在子卷实绩
				  if(list_mtd.size()>=Integer.parseInt(seqcount)){
					  MesRcmD mtd0=list_mtd.get(Integer.parseInt(seqcount)-1);
					  MesRcmD mtd0_new=new MesRcmD();
					  mtd0_new.setCoil_no(mtd0.getCoil_no());
					  mtd0_new.setAct_thk      ( v_rec_l2_pdo.getExit_thick()==null?null:strToLong(v_rec_l2_pdo.getExit_thick()).doubleValue()/1000);// --产出卷厚度um	
					  mtd0_new.setAct_len      ( v_rec_l2_pdo.getExit_length()==null?null:strToLong(v_rec_l2_pdo.getExit_length()).doubleValue()*1000);// --产出卷长度(m)																																							
					  mtd0_new.setAct_inn_dia  ( v_rec_l2_pdo.getInner_diameter()==null?null:strToLong(v_rec_l2_pdo.getInner_diameter()).doubleValue());// --产出卷内径																																							
					  mtd0_new.setAct_out_dia  ( v_rec_l2_pdo.getOuter_diameter()==null?null:strToLong(v_rec_l2_pdo.getOuter_diameter()).doubleValue());// --产出卷外径																																							
					  //mtd0_new.setCoil_thr_wgt ( v_rec_l2_pdo.getExit_calc_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_calc_weight()).doubleValue());// --产出卷理重	
					  mtd0_new.setCoil_thr_wgt ( v_rec_l2_pdo.getExit_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_weight()).doubleValue());// --产出卷理重	
					  mtd0_new.setCoil_act_wgt ( v_rec_l2_pdo.getExit_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_weight()).doubleValue());// --产出卷实量	
					  mtd0_new.setCoil_wgt_time(new Date());//出口卷称重时间
					  if(v_rec_l2_pdo.getExit_width()!=null){
						  mtd0_new.setAct_wdt(
								  v_rec_l2_pdo.getExit_width()==null?null:strToDouble(v_rec_l2_pdo.getExit_width()).doubleValue());
					  }
					  this.getMapper(MesRcmDMapper.class).update(mtd0_new);
					  
					//道次信息处理
					  try{
						  List<IfRoll01L2PdoPass> rcm_data = v_rec_l2_pdo.getRcm_data();
						  this.getMapper(MesRcmDPassMapper.class).doDelete(v_rec_Roll_m.getProcess_no(),mtd0.getCoil_no());
						  for(IfRoll01L2PdoPass pdo_pass:rcm_data){
							  if(pdo_pass.getCurr_pass_no()==null || "".equals(pdo_pass.getCurr_pass_no().trim())){
								  continue;
							  }
							  MesRcmDPass mrdp=new MesRcmDPass();
							  Date v_time=null;
							  try {
									List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(pdo_pass.getPass_start_time());
									v_time=li.get(0).getCreate_time();
									mrdp.setPass_start_time(v_time);
									List<MesCrAnnealM> li2 =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(pdo_pass.getPass_end_time());
									v_time=li2.get(0).getCreate_time();
									mrdp.setPass_end_time(v_time);
									mrdp.setCoil_no(mtd0.getCoil_no());
									mrdp.setCurr_pass_no(pdo_pass.getCurr_pass_no());
									mrdp.setEntry_tension_avg(strToDouble(pdo_pass.getEntry_tension_avg())==null?"":(strToDouble(pdo_pass.getEntry_tension_avg())+""));
									mrdp.setEntry_tension_max(strToDouble(pdo_pass.getEntry_tension_max())==null?"":(strToDouble(pdo_pass.getEntry_tension_max())+""));
									mrdp.setEntry_tension_min(strToDouble(pdo_pass.getEntry_tension_min())==null?"":(strToDouble(pdo_pass.getEntry_tension_min())+""));
									mrdp.setExit_tension_avg(strToDouble(pdo_pass.getExit_tension_avg())==null?"":(strToDouble(pdo_pass.getExit_tension_avg())+""));
									mrdp.setExit_tension_max(strToDouble(pdo_pass.getExit_tension_max())==null?"":(strToDouble(pdo_pass.getExit_tension_max())+""));
									mrdp.setExit_tension_min(strToDouble(pdo_pass.getExit_tension_min())==null?"":(strToDouble(pdo_pass.getExit_tension_min())+""));
									mrdp.setImr_bending_force(strToDouble(pdo_pass.getImr_bending_force())==null?"":(strToDouble(pdo_pass.getImr_bending_force())+""));
									mrdp.setMill_force(strToDouble(pdo_pass.getMill_force())==null?"":(strToDouble(pdo_pass.getMill_force())+""));
									mrdp.setMill_force_deta(strToDouble(pdo_pass.getMill_force_deta())==null?"":(strToDouble(pdo_pass.getMill_force_deta())+""));
									mrdp.setMill_speed(strToDouble(pdo_pass.getMill_speed())==null?"":(strToDouble(pdo_pass.getMill_speed())+""));
									mrdp.setMsg_time(new Date());
									mrdp.setPass_duration(strToDouble(pdo_pass.getPass_duration())==null?"":(strToDouble(pdo_pass.getPass_duration())+""));
									mrdp.setPass_entry_thick(strToDouble(pdo_pass.getPass_entry_thick())==null?"":(strToDouble(pdo_pass.getPass_entry_thick())+""));
									mrdp.setPass_exit_thick(strToDouble(pdo_pass.getPass_exit_thick())==null?"":(strToDouble(pdo_pass.getPass_exit_thick())+""));
									mrdp.setProcess_no(v_rec_Roll_m.getProcess_no());
									mrdp.setReduction(strToDouble(pdo_pass.getReduction())==null?"":(strToDouble(pdo_pass.getReduction())+""));
									mrdp.setShift_pos(strToDouble(pdo_pass.getShift_pos())==null?"":(strToDouble(pdo_pass.getShift_pos())+""));
									mrdp.setSpindle_torque(strToDouble(pdo_pass.getSpindle_torque())==null?"":(strToDouble(pdo_pass.getSpindle_torque())+""));
									mrdp.setWkr_bending_force(strToDouble(pdo_pass.getWkr_bending_force())==null?"":(strToDouble(pdo_pass.getWkr_bending_force())+""));
									this.getMapper(MesRcmDPassMapper.class).insert(mrdp);
								} catch (Exception e) {
									e.printStackTrace();
								}
						  }
					  }catch(Exception e){
						  e.printStackTrace();
					  }					  					  
				  }else{
					  MesRcmD mtd0_new=new MesRcmD();
					  mtd0_new.setAct_thk      ( v_rec_l2_pdo.getExit_thick()==null?null:strToLong(v_rec_l2_pdo.getExit_thick()).doubleValue()/1000);// --产出卷厚度um	
					  mtd0_new.setAct_len      ( v_rec_l2_pdo.getExit_length()==null?null:strToLong(v_rec_l2_pdo.getExit_length()).doubleValue()*1000);// --产出卷长度(m)																																							
					  mtd0_new.setAct_inn_dia  ( v_rec_l2_pdo.getInner_diameter()==null?null:strToLong(v_rec_l2_pdo.getInner_diameter()).doubleValue());// --产出卷内径																																							
					  mtd0_new.setAct_out_dia  ( v_rec_l2_pdo.getOuter_diameter()==null?null:strToLong(v_rec_l2_pdo.getOuter_diameter()).doubleValue());// --产出卷外径																																							
					  //mtd0_new.setCoil_thr_wgt ( v_rec_l2_pdo.getExit_calc_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_calc_weight()).doubleValue());// --产出卷理重																																							
					  mtd0_new.setCoil_thr_wgt ( v_rec_l2_pdo.getExit_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_weight()).doubleValue());// --产出卷理重																																							
					  mtd0_new.setCoil_act_wgt ( v_rec_l2_pdo.getExit_weight()==null?null:strToLong(v_rec_l2_pdo.getExit_weight()).doubleValue());// --产出卷实量	
					  ResultModel doAddmaterielWeb_PDO = new ResultModel();
					  //doAddmaterielWeb_PDO = this.getBean(MesRcmDServiceImpl.class).doAddmaterielWeb_PDO(MesRcmM.getSchedule_no(),
							 // MesRcmM.getMaterial_no_vt(),MesRcmM.getMaterial_no(),"M0008",mtd0_new);
					  
					  //道次信息处理
					  if(doAddmaterielWeb_PDO.getData()!=null){
						  
						  try{
							  List<IfRoll01L2PdoPass> rcm_data = v_rec_l2_pdo.getRcm_data();
							  //this.getMapper(MesRcmDPassMapper.class).doDelete(v_rec_Roll_m.getProcess_no(),mtd0.getCoil_no());
							  for(IfRoll01L2PdoPass pdo_pass:rcm_data){
								  if(pdo_pass.getCurr_pass_no()==null || "".equals(pdo_pass.getCurr_pass_no().trim())){
									  continue;
								  }
								  MesRcmDPass mrdp=new MesRcmDPass();
								  Date v_time=null;
								  try {
										List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(pdo_pass.getPass_start_time());
										v_time=li.get(0).getCreate_time();
										mrdp.setPass_start_time(v_time);
										List<MesCrAnnealM> li2 =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(pdo_pass.getPass_end_time());
										v_time=li2.get(0).getCreate_time();
										mrdp.setPass_end_time(v_time);
										mrdp.setCoil_no(doAddmaterielWeb_PDO.getData()+"");
										mrdp.setCurr_pass_no(pdo_pass.getCurr_pass_no());
										mrdp.setEntry_tension_avg(strToDouble(pdo_pass.getEntry_tension_avg())==null?"":(strToDouble(pdo_pass.getEntry_tension_avg())+""));
										mrdp.setEntry_tension_max(strToDouble(pdo_pass.getEntry_tension_max())==null?"":(strToDouble(pdo_pass.getEntry_tension_max())+""));
										mrdp.setEntry_tension_min(strToDouble(pdo_pass.getEntry_tension_min())==null?"":(strToDouble(pdo_pass.getEntry_tension_min())+""));
										mrdp.setExit_tension_avg(strToDouble(pdo_pass.getExit_tension_avg())==null?"":(strToDouble(pdo_pass.getExit_tension_avg())+""));
										mrdp.setExit_tension_max(strToDouble(pdo_pass.getExit_tension_max())==null?"":(strToDouble(pdo_pass.getExit_tension_max())+""));
										mrdp.setExit_tension_min(strToDouble(pdo_pass.getExit_tension_min())==null?"":(strToDouble(pdo_pass.getExit_tension_min())+""));
										mrdp.setImr_bending_force(strToDouble(pdo_pass.getImr_bending_force())==null?"":(strToDouble(pdo_pass.getImr_bending_force())+""));
										mrdp.setMill_force(strToDouble(pdo_pass.getMill_force())==null?"":(strToDouble(pdo_pass.getMill_force())+""));
										mrdp.setMill_force_deta(strToDouble(pdo_pass.getMill_force_deta())==null?"":(strToDouble(pdo_pass.getMill_force_deta())+""));
										mrdp.setMill_speed(strToDouble(pdo_pass.getMill_speed())==null?"":(strToDouble(pdo_pass.getMill_speed())+""));
										mrdp.setMsg_time(new Date());
										mrdp.setPass_duration(strToDouble(pdo_pass.getPass_duration())==null?"":(strToDouble(pdo_pass.getPass_duration())+""));
										mrdp.setPass_entry_thick(strToDouble(pdo_pass.getPass_entry_thick())==null?"":(strToDouble(pdo_pass.getPass_entry_thick())+""));
										mrdp.setPass_exit_thick(strToDouble(pdo_pass.getPass_exit_thick())==null?"":(strToDouble(pdo_pass.getPass_exit_thick())+""));
										mrdp.setProcess_no(v_rec_Roll_m.getProcess_no());
										mrdp.setReduction(strToDouble(pdo_pass.getReduction())==null?"":(strToDouble(pdo_pass.getReduction())+""));
										mrdp.setShift_pos(strToDouble(pdo_pass.getShift_pos())==null?"":(strToDouble(pdo_pass.getShift_pos())+""));
										mrdp.setSpindle_torque(strToDouble(pdo_pass.getSpindle_torque())==null?"":(strToDouble(pdo_pass.getSpindle_torque())+""));
										mrdp.setWkr_bending_force(strToDouble(pdo_pass.getWkr_bending_force())==null?"":(strToDouble(pdo_pass.getWkr_bending_force())+""));
										this.getMapper(MesRcmDPassMapper.class).insert(mrdp);
									} catch (Exception e) {
										e.printStackTrace();
									}
							  }
						  }catch(Exception e){
							  e.printStackTrace();
						  }
						  
					  }
					  
					  
				  }
				  
			  }
			
		}catch(Exception e){
			throw new Exception("此电文处理产出卷{"+seqcount+"}出错");
		}
		v_success=1;	
		v_message="Roll01L2Pdo【断带、分卷】L2钢卷生产实绩电文处理产出卷{"+seqcount+"}，处理成功！"+"_success:"+v_success;
		
		return v_message;
	}
	
	
	
	/**
	 * 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Pdo_d 方法调用；																																							
	    2)、	接口参数 IN：V_REC_L3_ASW_PDO（L3应答L2钢卷生产实绩对象）																																							
	    3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_rec_l3_asw_pdo
	 * @param v_message2
	 * @return
	 * @throws Exception
	 */
	@Transactional(propagation = Propagation.REQUIRES_NEW,value="tm", rollbackFor=Exception.class)
	public String Roll01L3AswPdo(IfRoll01L3AnswerPdo v_rec_l3_asw_pdo,
			String v_message) throws Exception{
		Integer v_flag=null;// --电文发送成功标志
		try{
			//  --(1)、无接口调试时，设置1，直接跳过，否则设置为0
			v_flag=0;// --1：成功、0：失败
			//--(1)、调用公司接口，将“L3应答L2钢卷生产实绩电文” v_rec_l3_asw_pdo 发送给L2（获取接口执行成功状态：v_flag，错误信息：v_message）
			
			JsonConfig jsonConfig=new JsonConfig();
			jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
			jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
			JSONObject jsonObject=JSONObject.fromObject(v_rec_l3_asw_pdo,jsonConfig);
			System.out.println(jsonObject.toString());
			try{
				log.debug("url:"+ROLLPDI_MES);
				String url = ROLLPDI_MES;
				String body = jsonObject.toString();
		        RestfulHttpClient.HttpResponse response = RestfulHttpClient.getClient(url)
		                .post()              //设置post请求
		                .addPostParam("body", "json")
		                .body(body)
		                .addHeader("Content-type", "application/json")   //添加header
		                //.addPathParam("id", "2")        //设置url路径参数
		                //.addQueryParam("test", "value") //设置url请求参数
		                .request();         //发起请求
		        System.out.println(response.getCode());     //响应状态码
		        System.out.println(response.getRequestUrl());//最终发起请求的地址
		        if(response.getCode() == 200){
		            //请求成功
		            //System.out.println(response.getContent());  //响应内容
		            log.debug("responseCONTENT:"+response.getContent());
		            if(response.getContent()!=null && (response.getContent().contains("vsuccess")|| response.getContent().contains("成功"))){//成功往L2的pdi表中插入数据
		            	v_flag=1;
		            	v_message="L3应答L2钢卷生产实绩电文下发成功！";
		            }else{
		            	if(response.getContent()!=null && response.getContent().length()>200){
		    				v_message="已下发L3应答L2钢卷生产实绩电文给L2，插入失败！【"+response.getContent().substring(0,200)+"】";
		    			}else{
		    				v_message="已下发L3应答L2钢卷生产实绩电文给L2，插入失败！【"+response.getContent()+"】";
		    			}
		            }
		        }else{
		        	v_message="下发无PDI给L2失败！发送请求失败！";
		        }
			}catch(Exception e){
				e.printStackTrace();
				v_message="【通讯过程出错："+e.getMessage()+"】";
			}
			
			
			
			
			// --(1.1)、电文发送失败（失败状态，根据接口提供定义确定）
			if(v_flag==0){
				v_message="Roll01L3AswPdo L3应答L2钢卷生产实绩电文发送失败！"+v_message;
				return v_message;
			}
			//--(1.2)、电文发送成功（成功状态，根据接口提供定义确定），插入 L3应答L2钢卷生产实绩 记录																																	
			this.getMapper(IfRoll01L3AnswerPdoMapper.class).insert(v_rec_l3_asw_pdo);
			// --(1.2.1)、提交事务
			v_message="Roll01L3AswPdo L3应答L2钢卷生产实绩电文发送成功！";
		}catch(Exception e){
			e.printStackTrace();
		    //--(1.2.2)、捕获未定义的异常，提示信息最多200字符																																							
		    //--(1.2.2.1)、电文发送成功（成功状态，根据接口提供定义确定）																																							
			if(v_flag==1){
				// --部分成功（电文已下发成功，但记录未写成功）
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3AswPdo L3应答L2钢卷生产实绩电文发送成功！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3AswPdo L3应答L2钢卷生产实绩电文发送成功！"+e.getMessage();
				}
			}else{
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3AswPdo L3应答L2钢卷生产实绩电文发送失败！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3AswPdo L3应答L2钢卷生产实绩电文发送失败！"+e.getMessage();
				}
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2生产结束电文时调用；																																							
		2)、	此接口参数为“L2生产结束电文JSON对象”（电文编号：DR3E09）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2ProduceEnd(IfRoll01L2PrdEnd json){
		String v_message="";
		String v_mch_code="M0008";
		//--(1)、参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_prd_end 代替描述
		IfRoll01L2PrdEnd v_rec_l2_prd_end=json;
		if(json==null ){
			v_message="参数错误：二级接口-轧机_L2_生产结束为空";
			return v_message;
		}
		//  --(1.1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_prd_end.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_prd_end.setMsg_time(new Date());
		}
		//--(1.2)、将对象，插入L2生产结束表（单独的事务）
		try{
			this.getMapper(IfRoll01L2PrdEndMapper.class).insert(v_rec_l2_prd_end);
		}catch(Exception e){
			e.printStackTrace();
		}
		//--(2)、调用L2生产结束处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2ProduceEnd_d(v_mch_code,v_rec_l2_prd_end,v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_prd_end.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String v_param = "消息时间 MSG_TIME {"+mes_time+"} 入口卷号 ENTRY_COIL_NO "
					+ "{"+v_rec_l2_prd_end.getEntry_coil_no()+"} 出口卷号 EXIT_COIL_NO {"+v_rec_l2_prd_end.getExit_coil_no()+"}";																																							
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2ProduceEnd",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}

	/**
	 *  1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2ProduceEnd 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_PRD_END（L2生产结束记录）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_prd_str
	 * @param v_message
	 * @return
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2ProduceEnd_d(String v_mch_code,
			IfRoll01L2PrdEnd v_rec_l2_prd_end, String v_message) throws Exception{
		Integer v_cnt=null;
		PlnRollingPlanDetail v_rec_pln_d=new PlnRollingPlanDetail();
		try{
			//  --(1)、验证传入参数的基本有效性
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--(1.2.1)、获取机台基础信息表中，配置的机台设备代号（设备编号，如1,2,3）
			ComBaseMachine cbm = this.getMapper(ComBaseMachineMapper.class).findById(v_mch_code);
			if(cbm.getMachine_mark()==null){
				v_message="机台代码{"+v_mch_code+"} 设备编号未配置，无法处理！";
				return v_message;
			}
			//  --(1.3)、验证入口卷号不为空
			if(v_rec_l2_prd_end.getEntry_coil_no()==null || "".equals(v_rec_l2_prd_end.getEntry_coil_no())){
				v_message="入口卷号{"+v_rec_l2_prd_end.getEntry_coil_no()+"} 未指定入口卷号！";
				return v_message;
			}
			if(v_rec_l2_prd_end.getEntry_coil_no().substring(0, 1).equals("L")){
				List<YdmProductDetail> listypd = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "materailcoilno='"+v_rec_l2_prd_end.getEntry_coil_no()+"'", "", 0, 0);
				if(listypd!=null && listypd.size()==1){
					v_rec_l2_prd_end.setEntry_coil_no(listypd.get(0).getCoilno());
					if(v_rec_l2_prd_end.getExit_coil_no()!=null){
						int ia=v_rec_l2_prd_end.getExit_coil_no().length()-v_rec_l2_prd_end.getEntry_coil_no().length();
						if(ia==1){
							String weihao = v_rec_l2_prd_end.getExit_coil_no().substring(v_rec_l2_prd_end.getExit_coil_no().length()-1, v_rec_l2_prd_end.getExit_coil_no().length());
							v_rec_l2_prd_end.setExit_coil_no(v_rec_l2_prd_end.getEntry_coil_no()+weihao);
						}
					}
				}
			}
			
			
			//  --(1.4)、“生产结束时间”赋值未当前时刻
			Date v_end_time=new Date();
			String rmDb=DateUtil.formatDate(v_end_time, "yyyy-MM-dd HH:mm:ss");
			String v_date=null,v_ord=null;
			String dbTime=rmDb.substring(11);
			v_date=rmDb.substring(0,10);
			if(dbTime.compareTo(DateUtil.NBeginTime)>-1&&dbTime.compareTo(DateUtil.BeginTime)<0){
				v_ord="1";
			}else if(dbTime.compareTo(DateUtil.BeginTime)>-1&&dbTime.compareTo(DateUtil.EndTime)<0){
				v_ord="2";
			}else if(dbTime.compareTo(DateUtil.EndTime)>-1&&dbTime.compareTo(DateUtil.NEndTime)<0){
				v_ord="1";
				SimpleDateFormat formatYmd = new SimpleDateFormat("yyyy-MM-dd");
				Date date;
				try {
					date = formatYmd.parse(v_date);
				} catch (Exception e) {
					return "获取数据库时间失败，请稍后重试";
				}
				Calendar c = Calendar.getInstance();  
		        c.setTime(date);  
		        c.add(Calendar.DAY_OF_MONTH, 1);//日期+1 
		        v_date=formatYmd.format(c.getTime());
			}
			//  --(2)、验证业务数据合理性																																							
			//  --(2.0)、根据计算的日期班次，获取交接班记录的班组																																							
			MesShiftM msm=new MesShiftM();
			msm.setMachine_code(v_mch_code);
			msm.setWrk_date(v_date);
			msm.setWrk_ord(v_ord);
			v_cnt=this.getMapper(MesShiftMMapper.class).count(msm);
			String v_grp=null;
			if(v_cnt<=0){
				v_grp="";// --暂无交接班记录，置空（由操作人员在页面上选取保存）
			}else{
				//    --否则获取交接班记录中的班组
				List<MesShiftM> lmsm = this.getMapper(MesShiftMMapper.class).find(msm, 0, 0);
				v_grp=lmsm.get(0).getWrk_grp();
			}
			//  --(2.1)、验证入口卷对应的作业计划信息存在  
			v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount1(v_mch_code,v_rec_l2_prd_end.getEntry_coil_no());
			if(v_cnt<=0){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_rec_l2_prd_end.getEntry_coil_no()+"} 找不到作业计划信息！";
				return v_message;  
			}else if(v_cnt>1){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_rec_l2_prd_end.getEntry_coil_no()+"}存在2条或以上的作业计划信息！";
				return v_message; 
			}else{
				List<PlnRollingPlanDetail> v_rec_pln_d_list=this.getMapper(PlnRollingPlanDetailMapper.class).doQuery3(v_mch_code, v_rec_l2_prd_end.getEntry_coil_no());
				v_rec_pln_d=v_rec_pln_d_list.get(0);
			}
			//  --(2.2)、如果已有生产实绩（人工操作或L2重复发送PDO情况下），且已交工，则返回（忽略此电文事件）
			MesRcmM mCross = new MesRcmM();
			mCross.setSchedule_no(v_rec_pln_d.getRl_plan_no());
			mCross.setMaterial_no(v_rec_l2_prd_end.getEntry_coil_no());
			v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
			MesRcmM v_rec_Roll_m=new MesRcmM();
			boolean flag=false;//
			if(v_cnt>0){
				List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
			    v_rec_Roll_m =lmcam.get(0);
			    flag=true;
			    if("1".equals(v_rec_Roll_m.getHand_over_status())){
			    	v_message = "机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} "
			    			+ "入口卷号{"+v_rec_l2_prd_end.getEntry_coil_no()+"} 已生产交工，忽略此电文事件！'";
					return v_message;
			    }
			}
			//  --(2.3)、验证虚拟物料表中，原料卷计划信息存在
			List<PlnMaterielDetail> v_rec_mtr_in_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_in_list==null || v_rec_mtr_in_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_prd_end.getEntry_coil_no()+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+"} 原料卷虚拟物料信息不存在！";																																							
				return v_message;
			}
			PlnMaterielDetail v_rec_mtr_in=v_rec_mtr_in_list.get(0);
			//  --(2.4)、验证原料卷号库存明细记录存在
			List<YdmProductDetail> v_rec_ydm_d_list = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "coilno='"+v_rec_l2_prd_end.getEntry_coil_no()+"'", null, 0, 0);
			if(v_rec_ydm_d_list==null || v_rec_ydm_d_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} "
						+ "入口卷号{"+v_rec_l2_prd_end.getEntry_coil_no()+"} 原料卷库存明细记录不存在！";
				return v_message;
			}
			YdmProductDetail v_rec_ydm_d=  v_rec_ydm_d_list.get(0);
			//  --(2.5)、验证虚拟物料表中，出口卷虚拟物料信息存在
			List<PlnMaterielDetail> v_rec_mtr_out_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"mat_object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_out_list==null || v_rec_mtr_out_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_rec_l2_prd_end.getEntry_coil_no()+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+" 出口卷虚拟物料信息不存在！";
				return v_message;
			}
			
			//2018-11-29 只有是已下发状态的钢卷才能下发
			if(v_rec_pln_d!=null){
				if(!("5BRL02".equals(v_rec_pln_d.getStatus()) || "5BRL03".equals(v_rec_pln_d.getStatus()))){
					v_message="当前状态{"+v_rec_pln_d.getStatus()+"}错误";
					return v_message;
				}
			}

			//  --(2.7)、在 v_rec_Roll_m 对象基础上，构建平整主实绩，并插入记录																																							
			//  --(2.7.1)：v_rec_Roll_m 对象可能不为空（之前实绩已存在），则更新部分信息，保留部分信息（未赋值的属性即是保留原有对象的属性值）																																							
			//  --(2.7.2)：v_rec_Roll_m 对象如果为空，请先实例化此对象（plsql示例逻辑无此问题）						
			ComBaseMachine machine2 = new ComBaseMachine();
			machine2.setMachine_code(v_mch_code);
			List<ComBaseMachine> lcbm = this.getMapper(ComBaseMachineMapper.class)
					.find(machine2, 0, 0);
			String v_mch_mark=lcbm.get(0).getMachine_mark();
			if (v_mch_mark == null) {
				return "机台代码：" +v_mch_code+ "\n设备编号未配置，无法处理！";
			}
			String v_process_no="";
			if(!flag){//如果 v_rec_plm_m 对象为空（即之前无生产实绩）
				SimpleDateFormat formatY3 = new SimpleDateFormat("yyMMdd");
				v_process_no = "Z" + formatY3.format(new Date())+lpad(v_mch_mark, 2, "0");
				v_cnt = this.getMapper(MesRcmMMapper.class).doquery(v_process_no);
				if (v_cnt == null) {
					v_cnt = 1;
				}
				v_process_no = v_process_no + lpad(v_cnt.toString(), 3, "0");
				v_rec_Roll_m.setProcess_no(v_process_no);
			}
			
			
			  v_rec_Roll_m.setMachine_code    ( v_mch_code);// --机台号（区分厂家：艾伯纳、中冶南方、宝信）																																							
			  v_rec_Roll_m.setSchedule_no     ( v_rec_pln_d.getRl_plan_no());// --作业计划号																																							
			  v_rec_Roll_m.setInner_seq       ( v_rec_pln_d.getRl_seq());// --计划内序号																																							
			  v_rec_Roll_m.setMaterial_no_vt  ( v_rec_pln_d.getObject_no_vt());// --虚拟原料卷号																																							
			  v_rec_Roll_m.setPln_steel_code  ( v_rec_mtr_in.getSteel_code());// --计划原料卷牌号																																							
			  v_rec_Roll_m.setPln_mtr_thk     ( v_rec_mtr_in.getThick());// --计划原料卷厚度																																							
			  v_rec_Roll_m.setPln_mtr_wdt     ( v_rec_mtr_in.getWidth());// --计划原料卷宽度																																							
			  v_rec_Roll_m.setPln_mtr_len     ( v_rec_mtr_in.getLength());// --计划原料卷长度																																							
			  v_rec_Roll_m.setPln_mtr_inn_dia ( v_rec_mtr_in.getDiameter_inn());// --计划原料卷内径																																							
			  v_rec_Roll_m.setPln_mtr_out_dia ( v_rec_mtr_in.getDiameter_out());// --计划原料卷外径																																							
			  v_rec_Roll_m.setPln_mtr_thr_wgt ( v_rec_mtr_in.getSingle_weight());// --计划原料卷理重																																							
			  v_rec_Roll_m.setMaterial_no     ( v_rec_l2_prd_end.getEntry_coil_no());// --原料卷号																																							
			  v_rec_Roll_m.setMaterial_no_src ( v_rec_ydm_d.getMaterailcoilno());// --原始卷号																																							
			  v_rec_Roll_m.setMtr_thk         ( v_rec_ydm_d.getThick());// --原料卷厚度																																							
			  v_rec_Roll_m.setMtr_wdt         ( v_rec_ydm_d.getWidth());// --原料卷宽度																																							
			  v_rec_Roll_m.setMtr_len         ( v_rec_ydm_d.getLength());// --原料卷长度																																							
			  v_rec_Roll_m.setMtr_inn_dia     ( v_rec_ydm_d.getDiameter_inn());// --原料卷内径																																							
			  v_rec_Roll_m.setMtr_out_dia     ( v_rec_ydm_d.getDiameter_out());// --原料卷外径																																							
			  if(v_rec_ydm_d.getTheoryweight()!=null){
				  v_rec_Roll_m.setMtr_thr_wgt     ( v_rec_ydm_d.getTheoryweight());// --原料卷理重	
			  }else{
				  v_rec_Roll_m.setMtr_thr_wgt     (v_rec_ydm_d.getFactweight());// --原料卷理重	
			  }
			  v_rec_Roll_m.setMtr_act_wgt     ( v_rec_ydm_d.getFactweight());// --原料卷实重																																							
			  v_rec_Roll_m.setSteel_code      ( v_rec_ydm_d.getSteelcode());// --原料卷牌号
			  
			  if(!flag){//如果 v_rec_Roll_m 对象为空（即之前无生产实绩），则覆盖 作业日期、班次、班组（与生产开始不同，请注意）
				  v_rec_Roll_m.setWrk_date     ( v_date);// --作业日期（YYYY-MM-DD）																																							
				  v_rec_Roll_m.setWrk_ord      ( v_ord); //--作业班次（0常白班、1晚班、2白班、3中班）																																							
				  v_rec_Roll_m.setWrk_grp      ( v_grp);// --作业班组（0常白班、1甲班、2乙班、3丙班、4丁班）																																							
				  v_rec_Roll_m.setFeeding_time ( v_end_time); //--上料时间		
				  v_rec_Roll_m.setTp_str_time  (v_end_time); //--生产开始时间
				  
			  }
			  v_rec_Roll_m.setMemo             ( null);// --备注																																							
			  v_rec_Roll_m.setHand_over_status ( "0");// --交工状态																																							
			  v_rec_Roll_m.setHand_over_time   ( null);// --交工时间																																							
			  v_rec_Roll_m.setHand_over_opr    ( null);// --交工人																																							
	
			  if(!flag){
				  //  --如果 v_rec_Roll_m 对象为空（即之前无生产实绩），则：
				  v_rec_Roll_m.setCreate_opr( "L2_DR3E09");// --操作人																																							
				  v_rec_Roll_m.setCreate_time( new Date());// --操作时间																																							
			  }else{
				  //  --如果 v_rec_Roll_m 对象不为空（即之前存在生产实绩），则（创建人、创建时间保留原值）：
				  v_rec_Roll_m.setUpdate_opr("L2_DR3E09");// --修改人																																							
				  v_rec_Roll_m.setUpdate_time(new Date()) ;//--修改时间																																							
			  }
			  
			  //--(3)、开始事物：																																							
			  //--(3.0)、更新生产跟踪表	??	
			  try{
				  int count = this.getMapper(MesRcmTrcMapper.class).countWithCondition(null,"machine_code='"+v_mch_code+"'"); 
				  if(count<=0){
					  	MesRcmTrc mcst=new MesRcmTrc();
					  	mcst.setMachine_code(v_mch_code);
					  	mcst.setLst_coil_no(v_rec_l2_prd_end.getEntry_coil_no());
					  	mcst.setLst_end_time(v_end_time);
					  	mcst.setUpdate_program("Roll01L2ProduceEnd");
					  	mcst.setUpdate_time(new Date());
						this.getMapper(MesRcmTrcMapper.class).insert(mcst);
				  }else{
					  MesRcmTrc v_rec_Roll_trc = this.getMapper(MesRcmTrcMapper.class).findById(v_mch_code);
					  // --(3.0.2)、如果生产结束入口卷号 = 生产跟踪表的当前钢卷号
					  if(v_rec_l2_prd_end.getEntry_coil_no().equals(v_rec_Roll_trc.getCur_coil_no())){
						    MesRcmTrc mcst=new MesRcmTrc();
						  	mcst.setMachine_code(v_mch_code);
						  	mcst.setLst_coil_no(v_rec_Roll_trc.getCur_coil_no());
						  	mcst.setLst_str_time(v_rec_Roll_trc.getCur_str_time());
						  	mcst.setLst_end_time(v_end_time);
						  	mcst.setCur_coil_no(null);
						  	mcst.setCur_str_time(null);
						  	mcst.setUpdate_program("Roll01L2ProduceEnd");
						  	mcst.setUpdate_time(new Date());
							this.getMapper(MesRcmTrcMapper.class).update(mcst);
					  }else if(v_rec_l2_prd_end.getEntry_coil_no().equals(v_rec_Roll_trc.getLst_coil_no())){//--(3.0.3)、如果生产结束入口卷号 = 生产跟踪表的上一钢卷号
						  MesRcmTrc mcstcc=new MesRcmTrc();
						  mcstcc.setMachine_code(v_mch_code);
						  mcstcc.setLst_end_time(v_end_time);
						  mcstcc.setUpdate_program("Roll01L2ProduceEnd");
						  mcstcc.setUpdate_time(new Date());
						  this.getMapper(MesRcmTrcMapper.class).update(mcstcc);
					  }
				  }
			  }catch(Exception e){
				  e.printStackTrace();
			  }
			  
			  //  --(3.1)、删除可能存在的平整作业实绩记录
			  this.getMapper(MesRcmMMapper.class).doDelete1(v_rec_pln_d.getRl_plan_no(),v_rec_l2_prd_end.getEntry_coil_no());
			  //  --(3.2)、插入平整作业实绩记录
			  this.getMapper(MesRcmMMapper.class).insert(v_rec_Roll_m);
			  
			  //--(3.3)、调用生产管理接口，执行业计划状态、物料进程状态相关操作（接口由生产管理模块提供）；；																																							
			  //--(3.3.1)、注意：可能在收到此PDO前，已执行过上料操作，并进行了此接口的操作，要求能正常处理，不能影响上述操作																																							
																																										
			  //--(3.4)、调用物流模块接口，执行原料卷生产投料出库相关操作（接口由物流模块提供）；																																							
			  //--(3.4.1)、注意：可能在收到此PDO前，已执行过上料操作，原料卷可能已投料出库，此时不能影响上述操作																																							
				MesRcmM  mcsm=new MesRcmM();
				mcsm.setMachine_code(v_mch_code);//机台号
				mcsm.setSchedule_no(v_rec_pln_d.getRl_plan_no());//作业计划号
				mcsm.setMaterial_no(v_rec_l2_prd_end.getEntry_coil_no());//投料卷号
				mcsm.setMaterial_no_vt(v_rec_pln_d.getObject_no_vt());//虚拟卷号 
				List<MesRcmM> lmcsm=new ArrayList<MesRcmM>();
				//时间
				SimpleDateFormat dfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");//设置日期格式
			    String date = dfs.format(new Date());// new Date()为获取当前系统时间，也可使用当前时间戳
			    mcsm.setMemo(date);
			    lmcsm.add(mcsm);
			   //调用生产管理接口验证作业计划状态能执行此操作
				boolean flag2=true;
				try{
					this.getBean(MesApiRollingPlanImpl.class).MesRcmMAddValid(lmcsm);
				}catch(Exception e){
					flag2=false;
					e.printStackTrace();
				}
				if(flag2){
					//调用生产管理接口，更改业计划状态（主表、从表）、原料虚拟物料进程状态
					this.getBean(MesApiRollingPlanImpl.class).MesRcmMAdd(lmcsm);
				}
				
				//调用物流模块（仓库管理）接口，对原料卷进行生产投料出库操作（接口由物流模块提供）；
				YdmProductOutlist ypo=new YdmProductOutlist();
				ypo.setCoilno(v_rec_l2_prd_end.getEntry_coil_no());
				ypo.setOuttype("500501");
				v_cnt = this.getMapper(YdmProductOutlistMapper.class).count(ypo);
				if(v_cnt<=0){
					CommonPage<YdmProductDetail> cp2=new CommonPage<YdmProductDetail>();
					YdmProductDetail ypdu=new YdmProductDetail();
					ypdu.setCoilno(v_rec_l2_prd_end.getEntry_coil_no());//注意
					// 传入操作时间字符串带毫秒
					ypdu.setMemo(date);
					cp2.setObject(ypdu);
					this.getBean(LmsApiServiceImpl.class).doOutStorage(cp2);
				}
			v_message = "Roll01L2ProduceEnd L2生产结束电文处理成功！";  
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2ProduceEnd L2生产结束电文处理失败！"+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2ProduceEnd L2生产结束电文处理失败！"+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2机组停机检测实绩电文时调用；																																							
		2)、	此接口参数为“L2机组停机检测实绩电文JSON对象”（电文编号：DR3E10）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2Stop(IfRoll01L2Stop json){
		String v_message="";
		String v_mch_code="M0008";
		//--(1)、参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_stop 代替描述
		IfRoll01L2Stop v_rec_l2_stop=json;
		if(json==null ){
			v_message="参数错误：二级接口-轧机_L2_机组停机检测为空";
			return v_message;
		}
		//  --(1、1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_stop.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_stop.setMsg_time(new Date());
		}
		//--(1.2)、将对象，插入L2机组停机检测表（单独的事务）
		try{
			if (!"0".equals(v_rec_l2_stop.getFlag()) || !"00000000000000".equals(v_rec_l2_stop.getTime())) {			
				this.getMapper(IfRoll01L2StopMapper.class).insert(v_rec_l2_stop);
			}
		}catch(Exception e){
			e.printStackTrace();
		}
		//--(2)、调用L2机组停机检测处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2Stop_d(v_mch_code,v_rec_l2_stop,
					v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_stop.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String  v_param = "消息时间 MSG_TIME {"+mes_time+"} 停机标识 FLAG {"+v_rec_l2_stop.getFlag()+"} "
					+ "停机时间 TIME {"+v_rec_l2_stop.getTime()+"} 原因代码 REASON_CODE {"+v_rec_l2_stop.getReason_code()+"}";																																							
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2Stop",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}
	
	/**
		1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Stop 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_STOP（L2机组停机检测记录）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_stop
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2Stop_d(String v_mch_code,
			IfRoll01L2Stop v_rec_l2_stop, String v_message) throws Exception{
		Integer v_cnt=null;
		try{
			//  --(1.1)、验证机台代码不为空
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//  --(2)、开始事物																																							
			//  --(2.1)、插入平整停开机记录																																							
			MesRcmStop mts=new MesRcmStop();
			mts.setMachine_code(v_mch_code);
			if(v_rec_l2_stop.getFlag()!=null){
				mts.setStop_flag(v_rec_l2_stop.getFlag()+"");
			}
			//??to_date(v_rec_l2_stop.time, 'yyyymmddhh24miss')？
			Date stop_time = null;
			try {
				List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(v_rec_l2_stop.getTime());
				stop_time=li.get(0).getCreate_time();
			} catch (Exception e) {
				
			}
			mts.setStop_time(stop_time);
			mts.setStop_reason(v_rec_l2_stop.getReason_code());
			mts.setCreate_opr("L2_DR3E10");
			mts.setCreate_time(new Date());
			this.getMapper(MesRcmStopMapper.class).insert(mts);
			//--(3)、提交事务
			v_message="Roll01L2Stop L2机组停机检测电文处理成功！";
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2Stop L2机组停机检测电文处理失败！"+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2Stop L2机组停机检测电文处理失败！"+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2能耗实绩电文时调用；																																							
		2)、	此接口参数为“L2能耗实绩电文JSON对象”（电文编号：DR3E11）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2Energy(IfRoll01L2Energy json){
		String v_message="";
		String v_mch_code="M0008";
		//--(1)、参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_energy 代替描述
		IfRoll01L2Energy v_rec_l2_energy=json;
		if(json==null ){
			v_message="参数错误：二级接口-轧机_L2_能耗实绩为空";
			return v_message;
		}
		//  --(1、1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_energy.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_energy.setMsg_time(new Date());
		}
		//--(1.2)、将对象，插入L2能耗实绩表（单独的事务）
		try{
			this.getMapper(IfRoll01L2EnergyMapper.class).insert(v_rec_l2_energy);
		}catch(Exception e){
			e.printStackTrace();
		}
		//  --(2)、调用L2能耗实绩处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2Energy_d(v_mch_code,v_rec_l2_energy,
					v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_energy.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String v_param = "消息时间 MSG_TIME {"+mes_time+"} 日期 TC_TIME {"+v_rec_l2_energy.getTc_time()+"} 班次 SHIFT {"+v_rec_l2_energy.getShift()+"} 班别 CREW {"+v_rec_l2_energy.getCrew()+"} 电 ELECTRICITY {"+v_rec_l2_energy.getElectricity()+
					  "} 净化水 PURIFY_WATER {"+v_rec_l2_energy.getPurify_water()+"} 循环水 CIRCULATING_WATER {"+v_rec_l2_energy.getCirculating_water()+"} 预留 RESERVER1 {"+v_rec_l2_energy.getReserver1()+"}";																																							
			
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2Energy",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}
	
	/**
	 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2Energy 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_ENERGY（L2能耗实绩记录）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_energy
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2Energy_d(String v_mch_code,IfRoll01L2Energy v_rec_l2_energy, 
			String v_message) throws Exception{
		Integer v_cnt=null;
		try{
			//  --(1.1)、验证机台代码不为空
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--(1.3)、验证日期
			if(v_rec_l2_energy.getTc_time()==null || "".equals(v_rec_l2_energy.getTc_time())){
				v_message="日期{"+v_rec_l2_energy.getTc_time()+"} 不能为空！";
				return v_message;
			}
			//--(1.3.1)、验证日期格式
			String v_wrk_date=null;
			try {
				v_wrk_date=this.getMapper(MesRcmMMapper.class).doQueryDate(v_rec_l2_energy.getTc_time());
			} catch (Exception e) {
				e.printStackTrace();
				v_message="日期{"+v_rec_l2_energy.getTc_time()+"} 格式无法识别！约定的标准格式【yyyymmdd】";
				return v_message;
			}
			//  --(1.4)、验证班次（1：晚、2：白、3：中）
			if(v_rec_l2_energy.getShift()==null){
				v_message="班次不能为空";
				return v_message;
			}else if(!"1".equals(v_rec_l2_energy.getShift()) && !"2".equals(v_rec_l2_energy.getShift())  
					&& !"3".equals(v_rec_l2_energy.getShift())) {
				v_message="班次{"+v_rec_l2_energy.getShift()+"}代码无法识别！";
				return v_message;
			}
			String v_wrk_ord=v_rec_l2_energy.getShift();
			
			//  --(2)、开始事物																																							
			//--(2.1)、验证平整能耗实绩是否存在			
			MesRcmEnergy mte=new MesRcmEnergy();
			mte.setMachine_code(v_mch_code);
			mte.setWrk_date(v_wrk_date);
			mte.setWrk_ord(v_wrk_ord);
		    v_cnt = this.getMapper(MesRcmEnergyMapper.class).count(mte);
		    if(v_cnt>0){
		    	//--(2.2)、存在则更新记录
		    	MesRcmEnergy m=new MesRcmEnergy();
		    	m.setMachine_code(v_mch_code);
		    	m.setWrk_date(v_wrk_date);
		    	m.setWrk_ord(v_wrk_ord);
		    	m.setCsm_elec(v_rec_l2_energy.getElectricity()==null?null:strToLong(v_rec_l2_energy.getElectricity()).doubleValue());
		    	m.setCsm_prf_water(v_rec_l2_energy.getPurify_water()==null?null:strToLong(v_rec_l2_energy.getPurify_water()).doubleValue()/100);
		    	m.setCsm_ccl_water(v_rec_l2_energy.getCirculating_water()==null?null:strToLong(v_rec_l2_energy.getCirculating_water()).doubleValue()/100);
		    	m.setUpdate_opr("L2_DR3E11");
		    	m.setUpdate_time(new Date());
		    	this.getMapper(MesRcmEnergyMapper.class).update(m);
		    }else{
		    	// --(2.3)、不存在则插入记录
		    	MesRcmEnergy m=new MesRcmEnergy();
		    	m.setMachine_code(v_mch_code);
		    	m.setWrk_date(v_wrk_date);
		    	m.setWrk_ord(v_wrk_ord);
		    	m.setCsm_elec(v_rec_l2_energy.getElectricity()==null?null:strToLong(v_rec_l2_energy.getElectricity()).doubleValue());
		    	m.setCsm_prf_water(v_rec_l2_energy.getPurify_water()==null?null:strToLong(v_rec_l2_energy.getPurify_water()).doubleValue()/100);
		    	m.setCsm_ccl_water(v_rec_l2_energy.getCirculating_water()==null?null:strToLong(v_rec_l2_energy.getCirculating_water()).doubleValue()/100);
		    	m.setCreate_opr("L2_DR3E11");
		    	m.setCreate_time(new Date());
		    	this.getMapper(MesRcmEnergyMapper.class).insert(m);
		    }
			//--(3)、提交事务
			v_message="Roll01L2Energy L2能耗实绩电文处理成功！";
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2Energy L2能耗实绩电文处理失败！"+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2Energy L2能耗实绩电文处理失败！"+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
		
	}

	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2应答L3指示删除电文时调用；																																							
		2)、	此接口参数为“L2应答L3指示删除电文JSON对象”（电文编号：DR3E12）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2AswRevoke(IfRoll01L2AnswerRevoke json){
		String v_message="";
		String v_mch_code="M0008";
		//--(1)、参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_asw_rvk 代替描述
		IfRoll01L2AnswerRevoke v_rec_l2_asw_rvk=json;
		if(json==null ){
			v_message="参数错误：二级接口-轧机_L2_应答L3指示删除为空";
			return v_message;
		}
		//  --(1、1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_asw_rvk.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_asw_rvk.setMsg_time(new Date());
		}
		//--(1.2)、将对象，插入L2应答L3指示删除表（单独的事务）
		try{
			this.getMapper(IfRoll01L2AnswerRevokeMapper.class).insert(v_rec_l2_asw_rvk);
		}catch(Exception e){
			e.printStackTrace();
		}
		//--(2)、调用应答L2应答L3指示删除处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2AswRevoke_d(v_mch_code,v_rec_l2_asw_rvk.getEntry_coil_no(),
					strToLong(v_rec_l2_asw_rvk.getResult()),v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_asw_rvk.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String  v_param = "消息时间 MSG_TIME {"+mes_time+"} 入口卷号 ENTRY_COIL_NO {"+v_rec_l2_asw_rvk.getEntry_coil_no()+"} 结果 RESULT {"+v_rec_l2_asw_rvk.getResult()+"}";																																							
			
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2AswRevoke",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}
	
	/**
	    1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2AswRevoke 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_ENTRY_COIL_NO（入口卷号）、V_RESULT（操作结果（1：成功、0：失败））																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param entry_coil_no
	 * @param result
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2AswRevoke_d(String v_mch_code, String v_entry_coil_no,
			Long v_result, String v_message) throws Exception{
		Integer v_cnt=null;
		PlnRollingPlanDetail v_rec_pln_d=new PlnRollingPlanDetail();
		try{
			//  --(1.1)、验证机台代码不为空
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--(1.3)、验证入口卷号不为空
			if(v_entry_coil_no==null || "".equals(v_entry_coil_no)){
				v_message="入口卷号{"+v_entry_coil_no+"} 未指定入口卷号！";
				return v_message;
			}
			//  --(2)、验证业务数据合理性																																							
			//  --(2.1)、验证入口卷对应的作业计划信息存在																																							
			v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount1(v_mch_code,v_entry_coil_no);
			if(v_cnt<=0){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 找不到作业计划信息！";
				return v_message;
			}else if(v_cnt>1){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"}存在2条或以上的作业计划信息！";
				return v_message;
			}else{
				List<PlnRollingPlanDetail> v_rec_pln_d_list=this.getMapper(PlnRollingPlanDetailMapper.class).doQuery3(v_mch_code, v_entry_coil_no);
				v_rec_pln_d=v_rec_pln_d_list.get(0);
			}
			//  --(2.2)、验证已下发过PDI
//			if(v_rec_pln_d.getSend_flag()==null || "0".equals(v_rec_pln_d.getSend_flag())){
//				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 还未下发指示顺序或PDI数据！";
//				return v_message;
//			}
			//  --(2.3)、验证当前还未生产交工
			MesRcmM mCross = new MesRcmM();
			mCross.setSchedule_no(v_rec_pln_d.getRl_plan_no());
			mCross.setMaterial_no(v_entry_coil_no);
			v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
			if(v_cnt>0){
				List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
			    MesRcmM v_rec_Roll_m =lmcam.get(0);
			    if("1".equals(v_rec_Roll_m.getHand_over_status())){
			    	v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 已生产交工！";
			    	return v_message;
			    }
			}
			//  --(3)、开始事物：																																							
			//  --(3.1)、如果应答电文中，RESULT = 0 即L2指示删除操作成功时，才修改L3对应指示状态																																							
			if(v_result==0){
				this.getMapper(PlnRollingPlanDetailMapper.class).doUpdate4("L2Asw", v_rec_pln_d.getRl_plan_no(), v_entry_coil_no);
			}
			//--(4)、提交事务
			v_message="Roll01L2AswRevoke L2应答L3指示删除电文处理成功！";
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2AswRevoke L2应答L3指示删除电文处理失败！"+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2AswRevoke L2应答L3指示删除电文处理失败！"+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}

	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2装辊实绩电文时调用；																																							
		2)、	此接口参数为“L2装辊实绩电文JSON对象”（电文编号：DR3E13）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2RllLoad(IfRoll01L2RllLoad json){
		String v_message="";
		String v_mch_code="M0008";
		//--(1)、参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_rll_load 代替描述
		IfRoll01L2RllLoad v_rec_l2_rll_load=json;
		if(json==null ){
			v_message="参数错误：二级接口-轧机_L2_装辊实绩为空";
			return v_message;
		}
		//--(1.0)、创建L2装辊实绩表记录号
		Long v_serial_no=this.getMapper(IfRoll01L2RllLoadMapper.class).doQuery1();
		//--(1.0.0)、赋值
		v_rec_l2_rll_load.setSerial_no(v_serial_no);
		//  --(1、1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_rll_load.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_rll_load.setMsg_time(new Date());
		}
		//  --(1.2)、将对象，插入 L2装辊实绩表 以及 L2装辊实绩表-上下辊表（单独的事务）																																							
		//  --(1.2.1)、此电文需要拆分为 主从表（1:2），其中上下辊为子表（编码时注意处理）	？？	  																																					
		try{
			this.getMapper(IfRoll01L2RllLoadMapper.class).insert(v_rec_l2_rll_load);
			//轧辊类型（WKR：工作辊、BUR： 支撑辊、IMR：中间辊）
			if(v_rec_l2_rll_load.getRoll_type()!=null){
				//W：工作辊、B：支承辊、I：中间辊）
				if(v_rec_l2_rll_load.getRoll_type().equals("WKR")){
					v_rec_l2_rll_load.setRoll_type("W");
				}else if(v_rec_l2_rll_load.getRoll_type().equals("BUR")){
					v_rec_l2_rll_load.setRoll_type("B");
				}else if(v_rec_l2_rll_load.getRoll_type().equals("IMR")){
					v_rec_l2_rll_load.setRoll_type("I");
				}
			}
			
			List<IfRoll01L2RllLoadD> litlrd = v_rec_l2_rll_load.getMount_roll();
			if(litlrd!=null && litlrd.size()>1){
				//this.getMapper(IfRoll01L2RllLoadDMapper.class).insert(v_rec_l2_rll_load_t);
				//this.getMapper(IfRoll01L2RllLoadDMapper.class).insert(v_rec_l2_rll_load_b);
				IfRoll01L2RllLoadD ilrld1=new IfRoll01L2RllLoadD();
				ilrld1.setSerial_no(v_serial_no);//记录号（由业务接口创建，唯一标识消息）
				ilrld1.setRoll_id(litlrd.get(0).getRoll_id());//轧辊号 ？？
				//ilrld1.setRoll_pos(litlrd.get(0).getReserve());//轧辊位置（T：上辊、B：下辊） ？？
				ilrld1.setRoll_pos("T");//轧辊位置（T：上辊、B：下辊） ？？
				ilrld1.setReserve(litlrd.get(0).getReserve());//预留
				this.getMapper(IfRoll01L2RllLoadDMapper.class).insert(ilrld1);
				IfRoll01L2RllLoadD ilrld2=new IfRoll01L2RllLoadD();
				ilrld2.setSerial_no(v_serial_no);//记录号（由业务接口创建，唯一标识消息）
				ilrld2.setRoll_id(litlrd.get(1).getRoll_id());//轧辊号 ？？
				//ilrld2.setRoll_pos(litlrd.get(1).getReserve());//轧辊位置（T：上辊、B：下辊） ？？
				ilrld2.setRoll_pos("B");//轧辊位置（T：上辊、B：下辊） ？？
				ilrld2.setReserve(litlrd.get(1).getReserve());//预留
				this.getMapper(IfRoll01L2RllLoadDMapper.class).insert(ilrld2);
			}
			
		}catch(Exception e){
			e.printStackTrace();
		}
		//--(2)、调用L2装辊实绩处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2RllLoad_d(v_mch_code,v_rec_l2_rll_load,v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_rll_load.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String  v_param = "消息时间 MSG_TIME {"+mes_time+"} 记录号 SERIAL_NO {"+v_rec_l2_rll_load.getSerial_no()+"}";
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2RllLoad",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}
	
	/**
	  	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2RllLoad 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_RLL_LOAD（L2装辊实绩记录）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_rll_load
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2RllLoad_d(String v_mch_code,
			IfRoll01L2RllLoad v_rec_l2_rll_load, String v_message) throws Exception{
		Integer v_cnt=null;
		try{
			//  --(1.1)、验证机台代码不为空
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--此电文需要轧辊管理功能完成后，再具体实现，先搭起此代码框架  ？？
			//执行上机操作
			
			/**
			 * 动作处理_上机按钮
			 * object:
			 * mount_time:上机时间    比如：2018-11-27 09:11:43
			 * mount_reason_code：上机原因代码（390203%）
			 * mount_reason_desc：上机原因描述
			 * stand_id:机架号
			 * mount_memo：上机备注
			 * 
			 * memo1:配辊记录号
			 * */
			CommonPage<DevRollerPairM> sum=new CommonPage<>();
		    sum.setObject(new DevRollerPairM());
			
			try {
				List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(v_rec_l2_rll_load.getMount_time());
				sum.getObject().setMount_time(li.get(0).getCreate_time());
			} catch (Exception e) {
				e.printStackTrace();
			}
			if(sum.getObject().getMount_time()==null){
				sum.getObject().setMount_time(new Date());
			}
			sum.getObject().setMount_reason_code(v_rec_l2_rll_load.getReason_code());
			sum.getObject().setMount_ord(v_rec_l2_rll_load.getShift());
			sum.getObject().setMount_grp(v_rec_l2_rll_load.getCrew());
			sum.getObject().setRoller_type(v_rec_l2_rll_load.getRoll_type());
			if(v_rec_l2_rll_load.getStand_id()!=null){
				sum.getObject().setStand_id(v_rec_l2_rll_load.getStand_id()+"");
			}
			sum.getObject().setMount_memo("收集L2装辊实绩信息");
			List<IfRoll01L2RllLoadD> litlrd = v_rec_l2_rll_load.getMount_roll();
			if(litlrd!=null && litlrd.size()>1){
				DevRollerPairM drpm=new DevRollerPairM();
				DevRollerInfo dri0 = this.getMapper(DevRollerInfoMapper.class).findById(litlrd.get(0).getRoll_id());
				DevRollerInfo dri1 = this.getMapper(DevRollerInfoMapper.class).findById(litlrd.get(1).getRoll_id());
				if(litlrd.get(0).getRoll_id()!=null && !"".equals(litlrd.get(0).getRoll_id()) &&
						litlrd.get(1).getRoll_id()!=null && !"".equals(litlrd.get(1).getRoll_id()) &&	
					dri0!=null && dri1!=null && dri0.getRoller_no()!=null && dri1.getRoller_no()!=null){
					DevRollerInfo dri0T=new DevRollerInfo();
					dri0T.setRoller_no(litlrd.get(0).getRoll_id());
					dri0T.setRoller_position("T");
					this.getMapper(DevRollerInfoMapper.class).update(dri0T);
					DevRollerInfo dri1B=new DevRollerInfo();
					dri1B.setRoller_no(litlrd.get(1).getRoll_id());
					dri1B.setRoller_position("B");
					this.getMapper(DevRollerInfoMapper.class).update(dri1B);
					
					if("T".equals(dri0.getRoller_position())){
						drpm.setT_roller_no(dri0.getRoller_no());
					}else if("B".equals(dri0.getRoller_position())){
						drpm.setB_roller_no(dri0.getRoller_no());
					}
					if("T".equals(dri1.getRoller_position())){
						drpm.setT_roller_no(dri1.getRoller_no());
					}else if("B".equals(dri1.getRoller_position())){
						drpm.setB_roller_no(dri1.getRoller_no());
					}
					if(drpm.getT_roller_no()!=null && drpm.getB_roller_no()!=null){
						drpm.setStatus("1");//配对状态，进行上机操作
						drpm.setMachine_code("M0008");
						List<DevRollerPairM> ldrpm = this.getMapper(DevRollerPairMMapper.class).find(drpm, 0, 0);
//						if(ldrpm==null || ldrpm.size()<=0){
//							try{
//								CommonPage<DevRollerInfo> sumxx=new CommonPage<DevRollerInfo>();
//								sumxx.setMemo2("1");//机架号
//								sumxx.setMemo3(dri0.getRoller_no());//上辊编号
//								sumxx.setMemo4(dri1.getRoller_no());//下辊编号
//								this.getBean(DevRollerPairDServiceImpl.class).doRollerPairWeb(sumxx);
//							}catch(Exception e){
//								e.printStackTrace();
//							}
//						}
						if(ldrpm!=null && ldrpm.size()>0){
							sum.setMemo1(ldrpm.get(0).getSerial_no());
							this.getBean(DevRollerPairMServiceImpl.class).doRollerPairUpWeb(sum);
						}
					}
					
				}
				
			}
			
			//--(4)、提交事务
			v_message="Roll01L2RllLoad L2装辊实绩电文处理成功！";
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2RllLoad L2装辊实绩电文处理失败！"+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2RllLoad L2装辊实绩电文处理失败！"+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}

	
	/**
		1)、	此接口为纯后台逻辑，不与前端页面交互，收到L2换辊实绩电文时调用；																																							
		2)、	此接口参数为“L2换辊实绩电文JSON对象”（电文编号：DR3E14）；																																							
	 * @param json
	 * @return
	 */
	public String Roll01L2RllRmv(IfRoll01L2RllRmv json){
		String v_message="";
		String v_mch_code="M0008";
		//--(1)、参数为JSON对象，先转换为Java实体类，此处以 v_rec_l2_rll_rmv 代替描述
		IfRoll01L2RllRmv v_rec_l2_rll_rmv=json;
		if(json==null ){
			v_message="参数错误：二级接口-轧机_L2_换辊实绩为空";
			return v_message;
		}
		//--(1.0)、创建L2装辊实绩表记录号
		Long v_serial_no=this.getMapper(IfRoll01L2RllRmvMapper.class).doQuery1();
		//--(1.0.0)、赋值
		v_rec_l2_rll_rmv.setSerial_no(v_serial_no);
		//  --(1、1)、如果电文中（接口参数）未包含消息时间（MSG_TIME），或为空值，则赋值为当前时刻
		if(v_rec_l2_rll_rmv.getMsg_time()==null){//作业时间为null，则取当前时间
			v_rec_l2_rll_rmv.setMsg_time(new Date());
		}
		//  --(1.2)、将对象，插入 L2换辊实绩表 以及 L2换辊实绩表-上下辊表（单独的事务）																																							
		//  --(1.2.1)、此电文需要拆分为 主从表（1:2），其中上下辊为子表（编码时注意处理）																																							
		try{
			this.getMapper(IfRoll01L2RllRmvMapper.class).insert(v_rec_l2_rll_rmv);
			//轧辊类型（WKR：工作辊、BUR： 支撑辊、IMR：中间辊）
			if(v_rec_l2_rll_rmv.getRoll_type()!=null){
				//W：工作辊、B：支承辊、I：中间辊）
				if(v_rec_l2_rll_rmv.getRoll_type().equals("WKR")){
					v_rec_l2_rll_rmv.setRoll_type("W");
				}else if(v_rec_l2_rll_rmv.getRoll_type().equals("BUR")){
					v_rec_l2_rll_rmv.setRoll_type("B");
				}else if(v_rec_l2_rll_rmv.getRoll_type().equals("IMR")){
					v_rec_l2_rll_rmv.setRoll_type("I");
				}
			}
			
			
			
			List<IfRoll01L2RllRmvD> litlrd = v_rec_l2_rll_rmv.getDismount_roll();
			if(litlrd!=null && litlrd.size()>1){
				IfRoll01L2RllRmvD ilrld1=new IfRoll01L2RllRmvD();
				ilrld1.setSerial_no(v_serial_no);//记录号（由业务接口创建，唯一标识消息）
				ilrld1.setRoll_id(litlrd.get(0).getRoll_id());//轧辊号 ？？
				DevRollerInfo dri0 = this.getMapper(DevRollerInfoMapper.class).findById(litlrd.get(0).getRoll_id());
				ilrld1.setRoll_pos(dri0==null?"":"T");//轧辊位置（T：上辊、B：下辊） ？？
				ilrld1.setRolled_length(litlrd.get(0).getRolled_length());//轧制公里数（km）??
				ilrld1.setRolled_weight(litlrd.get(0).getRolled_weight());//轧制量（t）
				ilrld1.setRolled_time(litlrd.get(0).getRolled_time());//生产时间（hours）
			    ilrld1.setReserve(litlrd.get(0).getReserve());//预留
				this.getMapper(IfRoll01L2RllRmvDMapper.class).insert(ilrld1);
				
				IfRoll01L2RllRmvD ilrld2=new IfRoll01L2RllRmvD();
				ilrld2.setSerial_no(v_serial_no);//记录号（由业务接口创建，唯一标识消息）
				ilrld2.setRoll_id(litlrd.get(1).getRoll_id());//轧辊号 ？？
				DevRollerInfo dri1 = this.getMapper(DevRollerInfoMapper.class).findById(litlrd.get(1).getRoll_id());
				ilrld2.setRoll_pos(dri1==null?"":"B");//轧辊位置（T：上辊、B：下辊） ？？
				ilrld2.setRolled_length(litlrd.get(1).getRolled_length());//轧制公里数（km）??
				ilrld2.setRolled_weight(litlrd.get(1).getRolled_weight());//轧制量（t）
				ilrld2.setRolled_time(litlrd.get(1).getRolled_time());//生产时间（hours）
			    ilrld2.setReserve(litlrd.get(1).getReserve());//预留
				this.getMapper(IfRoll01L2RllRmvDMapper.class).insert(ilrld2);
			}
			
		}catch(Exception e){
			e.printStackTrace();
		}
		//--(2)、调用L2换辊实绩处理函数
		try{
			v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L2RllRmv_d(v_mch_code,v_rec_l2_rll_rmv,v_message);
		}catch(Exception e){
			e.printStackTrace();
			v_message=e.getMessage();
		}finally{
			String mes_time=DateUtil.formatDate(v_rec_l2_rll_rmv.getMsg_time(), "yyyy-MM-dd HH:mm:ss");
			//  --(5)、拼接参数
			String  v_param = "消息时间 MSG_TIME {"+mes_time+"} 记录号 SERIAL_NO {"+v_rec_l2_rll_rmv.getSerial_no()+"}";
			//  --(6)、写接口日志：与业务处理分开，单独的事务
			try{
				 this.getMapper(IfRoll01LogMapper.class).doInsert(null,"Roll01L2RllRmv",v_param,v_message);
			}catch(Exception e){
				e.printStackTrace();
			}
		}
		return v_message;
	}
	
	/**
	 * 	1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由 Roll01L2RllRmv 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_REC_L2_RLL_RMV（L2换辊实绩记录）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param v_mch_code
	 * @param v_rec_l2_rll_rmv
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L2RllRmv_d(String v_mch_code,
			IfRoll01L2RllRmv v_rec_l2_rll_rmv, String v_message) throws Exception{
		Integer v_cnt=null;
		try{
			//  --(1.1)、验证机台代码不为空
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--此电文需要轧辊管理功能完成后，再具体实现，先搭起此代码框架  ？？
			//下机操作
			/**
			 * 动作处理_下机按钮
			 * object:
			 * dismount_time:下机时间    比如：2018-11-27 09:11:43
			 * dismount_reason_code：下机原因代码（390203%）
			 * dismount_reason_desc：下机原因描述
			 * rll_num:轧制卷数
			 * rll_len:轧制里程数（km）
			 * rll_wgt:轧制吨数（吨）
			 * dismount_memo：下机备注
			 * 
			 * memo1:配辊记录号
			 * */
			
			CommonPage<DevRollerPairM> sum=new CommonPage<>();
		    sum.setObject(new DevRollerPairM());
			
			try {
				List<MesCrAnnealM> li =this.getMapper(MesCrAnnealMMapper.class).doQueryDate(v_rec_l2_rll_rmv.getDismount_time());
				sum.getObject().setDismount_time(li.get(0).getCreate_time());
			} catch (Exception e) {
				e.printStackTrace();
			}
			if(sum.getObject().getDismount_time()==null){
				sum.getObject().setDismount_time(new Date());
			}
			sum.getObject().setDismount_reason_code(v_rec_l2_rll_rmv.getReason_code());
			sum.getObject().setDismount_ord(v_rec_l2_rll_rmv.getShift());
			sum.getObject().setDismount_grp(v_rec_l2_rll_rmv.getCrew());
			sum.getObject().setRoller_type(v_rec_l2_rll_rmv.getRoll_type());
			if(v_rec_l2_rll_rmv.getStand_id()!=null){
				sum.getObject().setStand_id(v_rec_l2_rll_rmv.getStand_id()+"");
			}
			sum.getObject().setDismount_memo("收集L2换辊实绩信息");
			
			List<IfRoll01L2RllRmvD> litlrd = v_rec_l2_rll_rmv.getDismount_roll();
			if(litlrd!=null && litlrd.size()>1){
				sum.getObject().setRll_len(litlrd.get(0).getRolled_length()==null?null:strToLong(litlrd.get(0).getRolled_length()).doubleValue());
				//sum.getObject().setRll_num(litlrd.get(0).get);// ??轧制卷数
				sum.getObject().setRll_wgt(litlrd.get(0).getRolled_weight()==null?null:strToLong(litlrd.get(0).getRolled_weight()).doubleValue());
				DevRollerPairM drpm=new DevRollerPairM();
				DevRollerInfo dri0 = this.getMapper(DevRollerInfoMapper.class).findById(litlrd.get(0).getRoll_id());
				DevRollerInfo dri1 = this.getMapper(DevRollerInfoMapper.class).findById(litlrd.get(1).getRoll_id());
				if(litlrd.get(0).getRoll_id()!=null && !"".equals(litlrd.get(0).getRoll_id()) &&
						litlrd.get(1).getRoll_id()!=null && !"".equals(litlrd.get(1).getRoll_id()) &&	
						dri0!=null && dri1!=null && dri0.getRoller_no()!=null && dri1.getRoller_no()!=null){
					DevRollerInfo dri0T=new DevRollerInfo();
					dri0T.setRoller_no(litlrd.get(0).getRoll_id());
					dri0T.setRoller_position("T");
					this.getMapper(DevRollerInfoMapper.class).update(dri0T);
					DevRollerInfo dri1B=new DevRollerInfo();
					dri1B.setRoller_no(litlrd.get(1).getRoll_id());
					dri1B.setRoller_position("B");
					this.getMapper(DevRollerInfoMapper.class).update(dri1B);
					
					
					if("T".equals(dri0.getRoller_position())){
						drpm.setT_roller_no(dri0.getRoller_no());
					}else if("B".equals(dri0.getRoller_position())){
						drpm.setB_roller_no(dri0.getRoller_no());
					}
					if("T".equals(dri1.getRoller_position())){
						drpm.setT_roller_no(dri1.getRoller_no());
					}else if("B".equals(dri1.getRoller_position())){
						drpm.setB_roller_no(dri1.getRoller_no());
					}
					if(drpm.getT_roller_no()!=null && drpm.getB_roller_no()!=null){
						drpm.setStatus("2");//上机状态，进行下机操作
						drpm.setMachine_code("M0008");
						List<DevRollerPairM> ldrpm = this.getMapper(DevRollerPairMMapper.class).find(drpm, 0, 0);
						if(ldrpm!=null && ldrpm.size()>0){
							sum.setMemo1(ldrpm.get(0).getSerial_no());
							this.getBean(DevRollerPairMServiceImpl.class).doRollerPairDownWeb(sum);
						}
					}
					
				}
				
			}
			
			//--(4)、提交事务
			v_message="Roll01L2RllRmv L2换辊实绩电文处理成功！";
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L2RllRmv L2换辊实绩电文处理失败！"+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L2RllRmv L2换辊实绩电文处理失败！"+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}

	/**
	 *  1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由“轧机作业管理-【下发PDI按钮】”方法 Roll01L3SendPdi 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_PLAN_NO（作业计划号）、V_ENTRY_COIL_NO（入口卷号）、V_OPR_NAME（操作人）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param memo1
	 * @param schedule_no
	 * @param material_no
	 * @param userName
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L3SendPdi_d(String v_mch_code, String v_plan_no,
			String v_entry_coil_no, String v_opr_name, String v_message) throws Exception{
		Integer v_cnt=null;
		PlnRollingPlanDetail v_rec_pln_d=new PlnRollingPlanDetail();
		try{
			//  --(1.1)、验证传入参数的基本有效性
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--(1.3)、验证作业计划号不为空
			if(v_plan_no==null || "".equals(v_plan_no)){
				v_message="未指定作业计划号！";
				return v_message;
			}
			//--(1.4)、验证入口卷号不为空
			if(v_entry_coil_no==null || "".equals(v_entry_coil_no)){
				v_message="未指定入口卷号！";
				return v_message;
			}
			//  --(2)、验证业务数据合理性																																							
			//  --(2.1)、验证入口卷对应的作业计划信息存在  																																							
			v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount6(v_mch_code, v_plan_no,v_entry_coil_no);
			if(v_cnt<=0){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 找不到作业计划信息！";
				return v_message;
			}else if(v_cnt>1){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"}存在2条或以上的作业计划信息！";
				return v_message;
			}else{
				List<PlnRollingPlanDetail> v_rec_pln_d_list=this.getMapper(PlnRollingPlanDetailMapper.class).doQuery3(v_mch_code, v_entry_coil_no);
				v_rec_pln_d=v_rec_pln_d_list.get(0);
			}
			//--(2.2)、验证入口卷对应的库存明细存在
			List<YdmProductDetail> v_rec_ydm_d_list = this.getMapper(YdmProductDetailMapper.class).findWithCondition(null, "coilno='"+v_entry_coil_no+"'", null, 0, 0);
			if(v_rec_ydm_d_list==null || v_rec_ydm_d_list.size()<=0){
				v_message="入口卷号{"+v_entry_coil_no+"}库存明细记录不存在！";
				return v_message;
			}
			YdmProductDetail v_rec_ydm_d=v_rec_ydm_d_list.get(0);
			//--(2.3)、验证入口卷对应的虚拟物料信息存在
			List<PlnMaterielDetail> v_rec_mtr_in_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
						"object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"' and object_no='"+v_rec_pln_d.getObject_no()+"'", null, 0, 0);
			if(v_rec_mtr_in_list==null || v_rec_mtr_in_list.size()<=0){
				v_message="入口卷号{"+v_entry_coil_no+"} 虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+"} 虚拟物料信息不存在！";
				return v_message;
			}
			
			//出口目标
			List<PlnMaterielDetail> v_rec_mtr_out_list = this.getMapper(PlnMaterielDetailMapper.class).findWithCondition(null, 
					"mat_object_no_vt='"+v_rec_pln_d.getObject_no_vt()+"'", null, 0, 0);
			if(v_rec_mtr_out_list==null || v_rec_mtr_out_list.size()<=0){
				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_rec_pln_d.getRl_plan_no()+"} 入口卷号{"+v_entry_coil_no+"} "
						+ "虚拟卷号{"+v_rec_pln_d.getObject_no_vt()+" 出口卷虚拟物料信息不存在！";
				return v_message;
			}
			PlnMaterielDetail v_rec_mtr_out=v_rec_mtr_out_list.get(0);
			//2018-11-29 只有是已下发状态的钢卷才能下发
			if(v_rec_pln_d!=null){
				if(!("5BRL02".equals(v_rec_pln_d.getStatus()) || "5BRL03".equals(v_rec_pln_d.getStatus()))){
					v_message="当前状态{"+v_rec_pln_d.getStatus()+"}错误";
					return v_message;
				}
			}
			
			//  --(2.4)、验证当前还未生产交工
			MesRcmM mCross = new MesRcmM();
			mCross.setSchedule_no(v_plan_no);
			mCross.setMaterial_no(v_entry_coil_no);
			v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
			if(v_cnt>0){
				List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
				MesRcmM v_rec_Roll_m  =lmcam.get(0);
			    if("1".equals(v_rec_Roll_m.getHand_over_status())){
			    	v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_plan_no+"} 入口卷号{"+v_entry_coil_no+"} 已生产交工，不能重复下发PDI！";
			    	return v_message;
			    }
			}
			//  --(3)、获取其它相关信息，注意忽略错误  																																							
			//  --(3.1)、获取牌号/钢种名称	
			String v_steel=null;
			List<ComBaseSteel> lcbs = this.getMapper(ComBaseSteelMapper.class).findWithCondition(null, "steel_code='"+v_rec_ydm_d.getSteelcode()+"'", null, 0, 0);
			if(lcbs==null || lcbs.size()<=0){
				v_steel=v_rec_ydm_d.getSteelcode();
			}else{
				if(lcbs.get(0).getSteel_name()==null){
					v_steel=lcbs.get(0).getSteel_code();
				}else{
					v_steel=lcbs.get(0).getSteel_name();
				}
			}
			//退火后进行轧制的，下发PDI，牌号需要加"-T"
			if (v_entry_coil_no.contains("T")) {
				v_steel = v_steel + "-T"; 
			}
			
			//--(3.2)、获取入口卷库位
			String v_entry_location=this.getMapper(MesCrAnnealMMapper.class).doQueryLocation(v_entry_coil_no);
			if(v_entry_location==null){
				v_entry_location="";
			}
			IfRoll01L3Pdi v_rec_pdi=new IfRoll01L3Pdi();
			//  --(4)、调用PDI数据下发函数																																							
			//  --(4.1)、PDI数据属性赋值（注意：记录号、下发时间、下发人，到调用接函数内才赋值）																																							
			  v_rec_pdi.setEntry_coil_no        ( v_entry_coil_no);// --入口卷号																																							
			  v_rec_pdi.setExit_coil_no         ( v_entry_coil_no);// --出口卷号																																							
			  v_rec_pdi.setEntry_coil_source    ( "1");// --入口卷来源（0：自产、1：外购）																																							
			  v_rec_pdi.setPlan_no              ( v_rec_pln_d.getRl_plan_no());// --计划号	
			  //List<PlnProdorder> v_rec_prod = this.getMapper(PlnProdorderMapper.class).findWithCondition(null, "prod_order_no='"+v_rec_mtr_in.getProd_order_no()+"'", null, 0, 0);
			  //v_rec_pdi.setCustomer(v_rec_prod.get(0).getCustomer_name());
			  //v_rec_pdi.setCustomer("下游客户");
			  v_rec_pdi.setSupplier(null);//原料供应商
			  if(v_rec_ydm_d.getLength()!=null){
				  Double len=v_rec_ydm_d.getLength()/1000;
				  v_rec_pdi.setEntry_length(longToString(len.longValue()));//来料长度
			  }
			  v_rec_pdi.setEntry_crown(null);//来料凸度
			  
			  
			  
			  if(v_rec_ydm_d.getThick()!=null){
				  Double thick=v_rec_ydm_d.getThick()*1000;
				  v_rec_pdi.setEntry_thichness( longToString(v_rec_ydm_d.getThick()==null?null:thick.longValue()));// --入口热卷厚度（um）
			  }
			  //出口厚度 
			  if (v_rec_pln_d.getThick()==null) {
				  v_rec_pdi.setExit_thickness(v_rec_mtr_out.getThick()+"");
			  }else {
				  v_rec_pdi.setExit_thickness(v_rec_pln_d.getThick()+"");
			  }
			  //v_rec_pdi.setExit_thickness(v_rec_mtr_out.getThick()==null?"":(v_rec_mtr_out.getThick()+""));
			  
			  v_rec_pdi.setEntry_width          ( longToString(v_rec_ydm_d.getWidth()==null?null:v_rec_ydm_d.getWidth().longValue()));// --入口热卷宽度（mm）																																							
			  v_rec_pdi.setEntry_weight         ( longToString(v_rec_ydm_d.getFactweight()==null?null:v_rec_ydm_d.getFactweight().longValue()));// --入口热卷重量（kg）																																							
			  v_rec_pdi.setInner_diameter       ( longToString(v_rec_ydm_d.getDiameter_inn()==null?null:v_rec_ydm_d.getDiameter_inn().longValue()));// --入口热卷内径（mm）																																							
			  v_rec_pdi.setOuter_diameter       ( longToString(v_rec_ydm_d.getDiameter_out()==null?null:v_rec_ydm_d.getDiameter_out().longValue()));// --入口热卷外径（mm）																																							
			  v_rec_pdi.setHarderness_annealing ( null);// --退火后硬度																																							
			  v_rec_pdi.setTemp_annealing       ( null);// --退火温度（℃）																																							
			  v_rec_pdi.setSpm_mode             ( "1");// --平整模式（0：平整、1：轧制），需要生产或质量提供接口																																							
			  v_rec_pdi.setSpm_elong            ( null);// --平整伸长率（0.01%，e.g. 255 => 2.55 %  ，平整模式），需要生产或质量提供接口																																							
			  v_rec_pdi.setReduce               ( null);// --压下率（%），需要生产或质量提供接口																																							
			  v_rec_pdi.setSleeve               ( "0");// --套筒（0：无、1：有），需要生产或质量提供接口																																							
			  v_rec_pdi.setOuter_dia_sleeve     ( null);// --出口套筒外径（520~600），需要生产或质量提供接口																																							
			  v_rec_pdi.setWeight_sleeve        ( null);// --套筒重量（kg），需要生产或质量提供接口																																							
			  v_rec_pdi.setGb_steel_grade       ( v_steel);// --国标钢种																																							
			  v_rec_pdi.setSteel_grade          ( v_steel);// --钢种																																							
			  v_rec_pdi.setPreced_process_code  ( "");// --上道工序代码																																							
			  v_rec_pdi.setNext_process_code    ( "");// --后道工序代码																																							
			  v_rec_pdi.setComment              ( "");// --备注信息																																							
			  //v_rec_pdi.setExit_yard_location   ( "test_loc");// --出口库位																																							
			  //v_rec_pdi.setEntry_yard_location  ( v_entry_location);// --入口库位																																							
			  v_rec_pdi.setReserve1              ( v_rec_ydm_d.getMaterailcoilno());// --预留	
			  try{
			  ResultModel getElementsInfo = this.getBean(QmsApiServiceImpl.class).GetElementsInfo(v_rec_ydm_d.getMaterailcoilno());
			  if(getElementsInfo!=null && getElementsInfo.getData()!=null){
				  List<QcmJhyElements> qje=(List)getElementsInfo.getData();
				  if(qje!=null && qje.size()>0){
					  for(QcmJhyElements qjed:qje){
						  //v_rec_pdi.setAlloy_components_avai(alloy_components_avai);
						  if("Als".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_als(qjed.getChem_value());
						  }else if("Alt".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_alt(qjed.getChem_value());
						  }else if("As".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_as(qjed.getChem_value());
						  }else if("B".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_b(qjed.getChem_value());
						  }else if("Bi".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_bi(qjed.getChem_value());
						  }else if("C".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_c(qjed.getChem_value());
						  }else if("Ca".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_ca(qjed.getChem_value());
						  }else if("Cd".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_cd(qjed.getChem_value());
						  }else if("Cr".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_cr(qjed.getChem_value());
						  }else if("Cu".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_cu(qjed.getChem_value());
						  }else if("Fe".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_fe(qjed.getChem_value());
						  }else if("La".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_la(qjed.getChem_value());
						  }else if("Mn".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_mn(qjed.getChem_value());
						  }else if("Mo".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_mo(qjed.getChem_value());
						  }else if("N".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_n(qjed.getChem_value());
						  }else if("Nb".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_nb(qjed.getChem_value());
						  }else if("Ni".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_ni(qjed.getChem_value());
						  }else if("P".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_p(qjed.getChem_value());
						  }else if("Pb".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_pb(qjed.getChem_value());
						  }else if("S".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_s(qjed.getChem_value());
						  }else if("Sb".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_sb(qjed.getChem_value());
						  }else if("Se".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_se(qjed.getChem_value());
						  }else if("Si".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_si(qjed.getChem_value());
						  }else if("Sn".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_sn(qjed.getChem_value());
						  }else if("Ti".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_ti(qjed.getChem_value());
						  }else if("V".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_v(qjed.getChem_value());
						  }else if("W".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_w(qjed.getChem_value());
						  }else if("Zn".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_zn(qjed.getChem_value());
						  }else if("Zr".equals(qjed.getChem_name())){
							  v_rec_pdi.setCa_zr(qjed.getChem_value());
						  }
						  
					  }
				  }
			  }
			  }catch(Exception e){
				  e.printStackTrace();
			  }
			  
			  
			  //测试内容：
//			   v_rec_pdi.setCa_c("0.45601");
//			   v_rec_pdi.setCa_mn("0.002");
			  try{
				  Integer v_success=null;
				  v_message=this.getBean(MesApiRollPdiPdoImpl.class).Roll01L3Pdi(v_rec_pdi,v_opr_name,v_success,v_message);
			  }catch(Exception e){
				  e.printStackTrace();
				  v_message=e.getMessage();
			  }
			  if(v_message==null){
					v_message="";
			  }
			 String v_success_str="";
			 if(v_message.contains("_success:")){
				v_success_str=v_message.substring(v_message.length()-1);
				v_message=v_message.substring(0, v_message.lastIndexOf("_success"));
			 }
			 if("1".equals(v_success_str)){
				 //v_message="PDI数据下发成功！"+v_message;
			 }else if("2".equals(v_success_str)){
				 v_message="PDI数据下发部分成功！"+v_message;
			 }else{
				 //v_message="PDI数据下发失败！"+v_message;
			 }
			
		}catch(Exception e){
			e.printStackTrace();
			if(e.getMessage()!=null && e.getMessage().length()>200){
				v_message="Roll01L3SendPdi_d处理出错："+e.getMessage().substring(0,200);
			}else{
				v_message="Roll01L3SendPdi_d处理出错："+e.getMessage();
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	/**
	 *  1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由“轧机作业管理-【撤销PDI按钮】”方法 Roll01L3Revoke 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_PLAN_NO（作业计划号）、V_ENTRY_COIL_NO（入口卷号）、V_OPR_NAME（操作人）																																							
		3)、	接口参数 OUT：V_SUCCESS（操作成功标志（1：成功、0：失败））、V_MESSAGE（操作结果信息）																																							
	 * @param memo1
	 * @param schedule_no
	 * @param material_no
	 * @param userName
	 * @param v_success
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L3Revoke_d(String v_mch_code, String v_plan_no,
			String v_entry_coil_no, String v_opr_name, Integer v_success,
			String v_message) throws Exception{
		//--(0)、置输出参数：操作成功标志为0：失败
		v_success=0;
		Integer v_cnt=null;
		Integer v_flag=null;
		//PlnRollingPlanDetail v_rec_pln_d=new PlnRollingPlanDetail();
		try{
			//  --(1.1)、验证机台代码不为空
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--(1.3)、验证作业计划号不为空
			if(v_plan_no ==null || "".equals(v_plan_no)){
				v_message="未指定作业计划号！";
				return v_message;
			}
			//  --(1.4)、验证入口卷号不为空
			if(v_entry_coil_no==null || "".equals(v_entry_coil_no)){
				v_message="未指定入口卷号！";
				return v_message;
			}
			//  --(2)、验证业务数据合理性																																							
			//  --(2.1)、验证入口卷对应的作业计划信息存在																																							
			v_cnt=this.getMapper(PlnRollingPlanMapper.class).doCount6(v_mch_code,v_plan_no,v_entry_coil_no);
			if(v_cnt<=0){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"} 找不到作业计划信息！";
				return v_message;
			}else if(v_cnt>1){
				v_message="机台代码{"+v_mch_code+"} 入口卷号{"+v_entry_coil_no+"}存在2条或以上的作业计划信息！";
				return v_message;
			}else{
				//List<PlnRollingPlanDetail> v_rec_pln_d_list=this.getMapper(PlnRollingPlanDetailMapper.class).doQuery3(v_mch_code, v_entry_coil_no);
				//v_rec_pln_d=v_rec_pln_d_list.get(0);
			}
			//  --(2.2)、验证已下发过PDI   切记???
//			if(v_rec_pln_d.getSend_flag()==null || "0".equals(v_rec_pln_d.getSend_flag())){
//				v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_plan_no+"} 入口卷号{"+v_entry_coil_no+"} 还未下发指示顺序或PDI数据！";
//				return v_message;
//			}
			//  --(2.3)、验证当前还未生产交工
			MesRcmM mCross = new MesRcmM();
			mCross.setSchedule_no(v_plan_no);
			mCross.setMaterial_no(v_entry_coil_no);
			v_cnt = this.getBean(MesRcmMMapper.class).count(mCross);
			if(v_cnt>0){
				List<MesRcmM> lmcam = this.getMapper(MesRcmMMapper.class).find(mCross, 0, 0);
			    MesRcmM v_rec_Roll_m =lmcam.get(0);
			    if("1".equals(v_rec_Roll_m.getHand_over_status())){
			    	v_message="机台代码{"+v_mch_code+"} 作业计划号{"+v_plan_no+"} 入口卷号{"+v_entry_coil_no+"} 已生产交工，不能撤销PDI！";
			    	return v_message;
			    }
			}
			
			//撤销PDI实体类
			IfRoll01L3Revoke itl=new IfRoll01L3Revoke();
			itl.setSend_time(new Date());
			itl.setSend_opr(v_opr_name);//注意L2是否扛得住？
			itl.setEntry_coil_no(v_entry_coil_no);
			
			v_flag=0;//--无接口调试时，设置1，直接跳过，否则设置为0
			//--(3)、调用公司接口，将“L3指示删除”电文发送给L2（电文格式见接口文档，获取接口执行成功状态：v_flag，错误信息：v_message）
			
			JsonConfig jsonConfig=new JsonConfig();
			jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
			jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
			JSONObject jsonObject=JSONObject.fromObject(itl,jsonConfig);
			System.out.println(jsonObject.toString());
			try{
				log.debug("url:"+ROLLPDI_ORDERDELE);
				String url = ROLLPDI_ORDERDELE;
				String body = jsonObject.toString();
		        RestfulHttpClient.HttpResponse response = RestfulHttpClient.getClient(url)
		                .post()              //设置post请求
		                .addPostParam("body", "json")
		                .body(body)
		                .addHeader("Content-type", "application/json")   //添加header
		                //.addPathParam("id", "2")        //设置url路径参数
		                //.addQueryParam("test", "value") //设置url请求参数
		                .request();         //发起请求
		        System.out.println(response.getCode());     //响应状态码
		        System.out.println(response.getRequestUrl());//最终发起请求的地址
		        if(response.getCode() == 200){
		            //请求成功
		            //System.out.println(response.getContent());  //响应内容
		            log.debug("responseCONTENT:"+response.getContent());
		            if(response.getContent()!=null && (response.getContent().contains("vsuccess")|| response.getContent().contains("成功"))){//成功往L2的pdi表中插入数据
		            	v_flag=1;
		            	v_message="L3指示删除电文下发成功！";
		            }else{
		            	if(response.getContent()!=null && response.getContent().length()>200){
		    				v_message="已下发L3指示删除电文给L2，插入失败！【"+response.getContent().substring(0,200)+"】";
		    			}else{
		    				v_message="已下发L3指示删除电文给L2，插入失败！【"+response.getContent()+"】";
		    			}
		            }
		        }else{
		        	v_message="下发L3指示删除电文给L2失败！发送请求失败！";
		        }
			}catch(Exception e){
				e.printStackTrace();
				v_message="【通讯过程出错："+e.getMessage()+"】";
			}
			
			// --(3.1)、电文发送失败（失败状态，根据接口提供定义确定）
			if(v_flag==0){
				v_message="Roll01L3Revoke L3指示删除电文发送失败！"+v_message;
				return v_message;
			}
			//  --(4)、开始事物：																																							
			//  --(4.1)、插入接口记录表相关信息																																							
			this.getMapper(IfRoll01L3RevokeMapper.class).insert(itl);
			
			// 撤销pdi的时候将send_flag值改回 0：20240701
			this.getMapper(PlnRollingPlanDetailMapper.class).doUpDelPdiStatus(v_plan_no, v_entry_coil_no);
			
			//--(5)、提交事务
			//唯一标示操作成功的地方
			v_success=1;
			v_message="Roll01L3Revoke L3指示删除电文发送成功！入口卷号{"+v_entry_coil_no+"}";
		}catch(Exception e){
			e.printStackTrace();
		    //--(6)、捕获未定义的异常，提示信息最多200字符																																							
		    //--(6.1)、电文发送成功（成功状态，根据接口提供定义确定）																																							
			if(v_flag==1){
				v_success=2;
				// --部分成功（电文已下发成功，但记录未写成功）
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3Revoke L3指示删除电文发送成功！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3Revoke L3指示删除电文发送成功！"+e.getMessage();
				}
			}else{
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3Revoke L3指示删除电文发送失败！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3Revoke L3指示删除电文发送失败！"+e.getMessage();
				}
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	
	/**
	    1)、	此函数为JAVA后台内调函数，可考虑将方法设为私有，由“轧辊配辊管理-【发送配辊信息至L2】（待设计开发）”方法 Roll01L3Roller 方法调用；																																							
		2)、	接口参数 IN：V_MCH_CODE（机台代码）、V_PAIR_NO（配辊编号）、V_ROLL_TYPE（轧辊类型（WKR：工作辊、BUR： 支撑辊、IMR：中间辊））、V_OPR_NAME（操作人）																																							
		3)、	接口参数 OUT：V_MESSAGE（操作结果信息）																																							
	 * @param memo1
	 * @param schedule_no
	 * @param material_no
	 * @param userName
	 * @param v_success
	 * @param v_message
	 * @return
	 * @throws Exception
	 */
	@Transactional(value="tm", rollbackFor=Exception.class)
	public String Roll01L3Roller_d(String v_mch_code, String v_pair_no,
			String v_roll_type, String v_opr_name,String v_message) throws Exception{
		Integer v_cnt=null;
		Integer v_flag=null;
		try{
			//  --(1.1)、验证机台代码不为空
			if(v_mch_code==null || "".equals(v_mch_code)){
				v_message="参数错误：机台代码不能为空！";
				return v_message;
			}
			//  --(1.2)、验证机台基础信息存在
			ComBaseMachine machine = new ComBaseMachine();
			machine.setMachine_code(v_mch_code);
			v_cnt = this.getMapper(ComBaseMachineMapper.class).count(machine);
			if (v_cnt <= 0) {
				v_message = ("机台代码：{" + v_mch_code+ "}机台基础信息不存在！");
				return v_message;
			}
			//--(1.3)、验证配辊编号不为空
			if(v_pair_no ==null || "".equals(v_pair_no)){
				v_message="未指定配辊编号！";
				return v_message;
			}
			//--轧辊类型（WKR：工作辊、BUR： 支撑辊、IMR：中间辊）
			if(v_roll_type==null || "".equals(v_roll_type)){
				v_message="未指定轧辊类型！";
				return v_message;
			}
			
			List<DevRollerPairM> ldbgg = this.getMapper(DevRollerPairMMapper.class).findWithCondition(null, "serial_no='"+v_pair_no+"'", null, 0, 0);
			DevRollerPairM v_rec_grd = ldbgg.get(0);
			DevRollerPairD t_drpd=new DevRollerPairD();
			t_drpd.setSerial_no(v_rec_grd.getSerial_no());
			//轧辊位置（T：上辊、B：下辊）
			t_drpd.setRoller_position("T");
			List<DevRollerPairD> t_drpd_list = this.getMapper(DevRollerPairDMapper.class).find(t_drpd,0,0);
			
			DevRollerPairD b_drpd=new DevRollerPairD();
			b_drpd.setSerial_no(v_rec_grd.getSerial_no());
			//轧辊位置（T：上辊、B：下辊）
			b_drpd.setRoller_position("B");
			List<DevRollerPairD> b_drpd_list = this.getMapper(DevRollerPairDMapper.class).find(b_drpd,0,0);
			
			IfRollRollerView itrv=new IfRollRollerView();
			IfRoll01L3Roller v_rec_roller=new IfRoll01L3Roller();
			IfRoll01L3RollerD v_rec_roller_t=new IfRoll01L3RollerD();
			IfRoll01L3RollerD v_rec_roller_b=new IfRoll01L3RollerD();
			//2019-03-01
			Long max_serial_no=this.getMapper(IfRoll01L3RollerMapper.class).doQuery1();
			v_rec_roller.setSerial_no(max_serial_no);
				
			
			
			//--(4)、轧辊数据属性赋值
			v_rec_roller.setArea_id("1");//--轧辊区域（1：冷轧钢、2：平整）
			v_rec_roller.setStand_id(longToString(Long.parseLong(v_rec_grd.getStand_id())));
			v_rec_roller.setRoll_type(v_rec_grd.getRoller_type());
			itrv.setArea_id("1");//--轧辊区域（1：冷轧钢、2：平整）
			itrv.setStand_id(longToString(Long.parseLong(v_rec_grd.getStand_id())));
			//轧辊类型（WKR：工作辊、BUR： 支撑辊、IMR：中间辊）
			if(v_rec_grd.getRoller_type()!=null){
				//W：工作辊、B：支承辊、L：中间辊）
				if(v_rec_grd.getRoller_type().equals("W")){
					itrv.setRoll_type("WKR");
				}else if(v_rec_grd.getRoller_type().equals("B")){
					itrv.setRoll_type("BUR");
				}else if(v_rec_grd.getRoller_type().equals("L")){
					itrv.setRoll_type("IMR");
				}
			}
			
			
			//v_rec_roller_t.setSerial_no(Long.parseLong(t_drpd_list.get(0).getSerial_no().substring(1)));
			v_rec_roller_t.setSerial_no(max_serial_no);
			v_rec_roller_t.setRoll_pos(t_drpd_list.get(0).getRoller_position());
			v_rec_roller_t.setRoll_id(t_drpd_list.get(0).getRoller_no());
			if(t_drpd_list.get(0).getDia_current()!=null){
				Double dia_current=t_drpd_list.get(0).getDia_current()*1000;
				v_rec_roller_t.setDiameter(longToString(dia_current.longValue()));  //直径（10^-3 mm）
			}
			if(t_drpd_list.get(0).getConvexity()!=null){
				Double convexity=t_drpd_list.get(0).getConvexity()*1000;
				v_rec_roller_t.setCrown(longToString(convexity.longValue()));//微米
			}
			if(t_drpd_list.get(0).getCone_len()!=null){
				v_rec_roller_t.setL_cone(longToString(t_drpd_list.get(0).getCone_len().longValue()));
			}
			if(t_drpd_list.get(0).getCone_hgt()!=null){
				Double cone_hgt=t_drpd_list.get(0).getCone_hgt()*1000;
				v_rec_roller_t.setH_cone(longToString(cone_hgt.longValue()));
			}
			if(t_drpd_list.get(0).getRoughness()!=null){
				Double roughness=t_drpd_list.get(0).getRoughness();
				v_rec_roller_t.setRoughness(longToString(roughness.longValue()));
			}
			//v_rec_roller_t.setProperty_class(t_drpd_list.get(0).getMaterial_code());//PROPERTY_CLASS材质代码（0：光棍、1：毛辊）
			
			//v_rec_roller_b.setSerial_no(Long.parseLong(b_drpd_list.get(0).getSerial_no().substring(1)));
			v_rec_roller_b.setSerial_no(max_serial_no);
			v_rec_roller_b.setRoll_pos(b_drpd_list.get(0).getRoller_position());
			v_rec_roller_b.setRoll_id(b_drpd_list.get(0).getRoller_no());
			if(b_drpd_list.get(0).getDia_current()!=null){
				Double dia_current=b_drpd_list.get(0).getDia_current()*1000;
				v_rec_roller_b.setDiameter(longToString(dia_current.longValue()));  //直径（10^-3 mm）
			}
			if(b_drpd_list.get(0).getConvexity()!=null){
				Double convexity=b_drpd_list.get(0).getConvexity()*1000;
				v_rec_roller_b.setCrown(longToString(convexity.longValue()));//微米
			}
			if(b_drpd_list.get(0).getCone_len()!=null){
				v_rec_roller_b.setL_cone(longToString(b_drpd_list.get(0).getCone_len().longValue()));
			}
			if(b_drpd_list.get(0).getCone_hgt()!=null){
				Double cone_hgt=b_drpd_list.get(0).getCone_hgt()*1000;
				v_rec_roller_b.setH_cone(longToString(cone_hgt.longValue()));
			}
			if(b_drpd_list.get(0).getRoughness()!=null){
				Double roughness=b_drpd_list.get(0).getRoughness();
				v_rec_roller_b.setRoughness(longToString(roughness.longValue()));
			}
			//v_rec_roller_b.setProperty_class(b_drpd_list.get(0).getMaterial_code());//PROPERTY_CLASS材质代码（0：光棍、1：毛辊）
			
			itrv.getRoll_data().add(v_rec_roller_t);
			itrv.getRoll_data().add(v_rec_roller_b);
			
			
//			//340.092  直径
//			//340.08 
//			IfRollRollerView itrv=new IfRollRollerView();
//			List<IfRoll01L3RollerD> roll_data=new ArrayList<>();
//			IfRoll01L3RollerD ifroll1=new IfRoll01L3RollerD();
//			ifroll1.setRoll_id("234R134");
//			ifroll1.setDiameter("340.092");
//			IfRoll01L3RollerD ifroll2=new IfRoll01L3RollerD();
//			ifroll2.setRoll_id("222R134");
//			ifroll2.setDiameter("340.08");
//			roll_data.add(ifroll1);
//			roll_data.add(ifroll2);
//			itrv.setArea_id("1");
//			itrv.setRoll_data(roll_data);
//			itrv.setStand_id("2");
//			itrv.setRoll_type("WKR");
			
			//--(4.1)、置输出参数：操作成功标志为0：失败
			v_flag=0;// --无接口调试时，设置1，直接跳过，否则设置为0
			//--(4.2)、调用公司接口，将“轧辊数据”电文发送给L2（电文格式见接口文档，获取接口执行成功状态：v_flag，错误信息：v_message）
			
			JsonConfig jsonConfig=new JsonConfig();
			jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
			jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
			jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
			JSONObject jsonObject=JSONObject.fromObject(itrv,jsonConfig);
			System.out.println(jsonObject.toString());
			try{
				log.debug("url:"+ROLLPDI_ROLLING);
				String url = ROLLPDI_ROLLING;
				String body = jsonObject.toString();
		        RestfulHttpClient.HttpResponse response = RestfulHttpClient.getClient(url)
		                .post()              //设置post请求
		                .addPostParam("body", "json")
		                .body(body)
		                .addHeader("Content-type", "application/json")   //添加header
		                //.addPathParam("id", "2")        //设置url路径参数
		                //.addQueryParam("test", "value") //设置url请求参数
		                .request();         //发起请求
		        System.out.println(response.getCode());     //响应状态码
		        System.out.println(response.getRequestUrl());//最终发起请求的地址
		        if(response.getCode() == 200){
		            //请求成功
		            //System.out.println(response.getContent());  //响应内容
		            log.debug("responseCONTENT:"+response.getContent());
		            if(response.getContent()!=null && (response.getContent().contains("vsuccess")|| response.getContent().contains("成功"))){//成功往L2的pdi表中插入数据
		            	v_flag=1;
		            	v_message="轧辊数据电文下发成功！";
		            }else{
		            	if(response.getContent()!=null && response.getContent().length()>200){
		    				v_message="已下发轧辊数据电文给L2，插入失败！【"+response.getContent().substring(0,200)+"】";
		    			}else{
		    				v_message="已下发轧辊数据电文给L2，插入失败！【"+response.getContent()+"】";
		    			}
		            }
		        }else{
		        	v_message="下发轧辊数据电文给L2失败！发送请求失败！";
		        }
			}catch(Exception e){
				e.printStackTrace();
				v_message="【通讯过程出错："+e.getMessage()+"】";
			}
			
			
			
			
			
			// --(4.2.1)、电文发送失败（失败状态，根据接口提供定义确定）
//			if(v_flag==0){
//				v_message="Roll01L3Roller 轧辊数据电文发送失败！";
//				return v_message;
//			}
//			//  --(5)、插入接口记录表相关信息																																							
//			//  --(5.1)、开始事物：					
//			try{
//			//  --(5.1.1)、插入 IF_Roll01_L3_ROLLER 记录																																							
//				this.getMapper(IfRoll01L3RollerMapper.class).insert(v_rec_roller);	
//				//--(5.1.2)、插入 IF_Roll01_L3_ROLLER_D 上辊记录
//				this.getMapper(IfRoll01L3RollerDMapper.class).insert(v_rec_roller_t);
//				//--(5.1.3)、插入 IF_Roll01_L3_ROLLER_D 下辊记录
//				this.getMapper(IfRoll01L3RollerDMapper.class).insert(v_rec_roller_b);
//			}catch(Exception e){
//				e.printStackTrace();
//			}
//			
//			//--(5.1.4)、修改配辊记录表中，下发L2状态
//			//状态（1：配对、2：上机、3：下机、0：拆卸）
//			DevRollerPairM drpm=new DevRollerPairM();
//			drpm.setSerial_no(v_rec_grd.getSerial_no());
//			drpm.setSend_l2("1");
//			drpm.setUpdate_opr(v_opr_name);
//			drpm.setUpdate_time(new Date());
//			this.getMapper(DevRollerPairMMapper.class).update(drpm);
//			// --(6)、提交事务
//			v_message="Roll01L3Roller 轧辊数据电文发送成功！记录号{"+v_rec_grd.getSerial_no()+"}";
		}catch(Exception e){
			e.printStackTrace();
		    //--(7)、捕获未定义的异常，提示信息最多200字符																																							
		    //--(7.1)、电文发送成功（成功状态，根据接口提供定义确定）																																							
			if(v_flag==1){
				// --部分成功（电文已下发成功，但记录未写成功）
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3Roller 轧辊数据电文发送成功！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3Roller 轧辊数据电文发送成功！"+e.getMessage();
				}
			}else{
				if(e.getMessage()!=null && e.getMessage().length()>200){
					v_message="Roll01L3Roller 轧辊数据电文发送失败！"+e.getMessage().substring(0,200);
				}else{
					v_message="Roll01L3Roller 轧辊数据电文发送失败！"+e.getMessage();
				}
			}
			throw new Exception(v_message);
		}
		return v_message;
	}
	
	public String Roll01L2Pdileotest(IfRoll01L3Pdi json){
		
		return "测试内容76与66";
	}
	
	
	public void testgetObjectJson(){
		IfRollRollerView itrv=new IfRollRollerView();
//		itrv.setArea_id(111l);
//		itrv.setStand_id(3l);
//		itrv.setRoll_type("wtr");
//		IfRoll01L3RollerD  d1=new IfRoll01L3RollerD();
//		d1.setCrown(367l);
//		d1.setL_cone(903l);
//		d1.setRoll_pos("T");
//		d1.setRoll_id("roid2018");
//		IfRoll01L3RollerD  d2=new IfRoll01L3RollerD();
//		d2.setCrown(367l);
//		d2.setL_cone(903l);
//		d2.setRoll_pos("B");
//		d2.setRoll_id("roid2020");
//		itrv.getRoll_data().add(d1);
//		itrv.getRoll_data().add(d2);
		
		JsonConfig jsonConfig=new JsonConfig();
		jsonConfig.registerJsonValueProcessor(java.util.Date.class, new DateJsonValueProcessor("yyyy-MM-dd HH:mm:ss"));
		jsonConfig.registerJsonValueProcessor(java.lang.Double.class, new DoubleJsonValueProcessor());
		jsonConfig.registerJsonValueProcessor(java.lang.Long.class, new LongJsonValueProcessor());
		jsonConfig.registerJsonValueProcessor(java.lang.Integer.class, new IntegerJsonValueProcessor());
		JSONObject jsonObject=JSONObject.fromObject(itrv,jsonConfig);
		System.out.println(jsonObject.toString());
		/*
		 {"roll_type":"wtr","stand_id":3,"area_id":111,"litlrd":[{"roll_pos":"T","l_cone":903,"diameter":"","roughness":"","reserve":"","roll_id":"roid2018","h_cone":"","property_class":"","serial_no":"","crown":367},{"roll_pos":"B","l_cone":903,"diameter":"","roughness":"","reserve":"","roll_id":"roid2020","h_cone":"","property_class":"","serial_no":"","crown":367}]}
		 */
	}
	
	public Long strToLong(String str){
		if(str==null || "".equals(str.trim())){
			return null;
		}
		return Long.parseLong(str);
	}
	
	public String longToString(Long str){
		if(str==null){
			return null;
		}
		return str+"";
	}
	
	public Double strToDouble(String str){
		if(str==null || "".equals(str.trim())){
			return null;
		}
		Double leo=null;
		try{
			leo=Double.parseDouble(str);
		}catch(Exception ex){
			return null;
		}
		return leo;
	}
	
	public static void main(String[] args){
		MesApiRollPdiPdoImpl marp=new MesApiRollPdiPdoImpl();
		System.out.println(marp.strToLong("345"));//345
		System.out.println(marp.strToDouble("00044.0000"));//44.0
		System.out.println(marp.strToDouble("00032.1761"));//32.1761
		System.out.println(marp.strToDouble("00000.0000"));//0.0
		System.out.println(marp.strToDouble("750.00"));//750.0
		System.out.println(marp.strToLong("000750"));//750
		System.out.println(marp.strToDouble("000750"));//750.0
		System.out.println(marp.strToLong("000750").doubleValue()/1000);//0.75
		System.out.println(marp.strToDouble("750"));//750.0
		System.out.println(marp.strToDouble("001225.0").doubleValue());//1225.0
	}
	
	// 补零
	public static String lpad(String str, int num, String pad) {
		String n_str = str;
		if (str == null && "".equals(str))
			n_str = " ";
		for (int i = str.length(); i < num; i++) {
			n_str = pad + n_str;
		}
		return n_str;
	}

}
