package com.shlanbao.tzsc.base.interceptor;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import com.shlanbao.tzsc.base.mapping.*;
import com.shlanbao.tzsc.init.BaseParams;
import com.shlanbao.tzsc.plugin.service.LoadComboboxServiceI;
import com.shlanbao.tzsc.pms.cos.spare.beans.CosSparePartsBean;
import com.shlanbao.tzsc.pms.md.unit.beans.UnitBean;
import com.shlanbao.tzsc.pms.md.unit.service.UnitServiceI;

import com.shlanbao.tzsc.pms.sch.workorder.beans.TransmitterWorkOrderBean;
import com.shlanbao.tzsc.utils.params.ComboboxType;
import com.shlanbao.tzsc.utils.tools.*;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.log4j.Logger;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.StringUtils;

import com.shlanbao.tzsc.pms.md.eqp.beans.EquipmentsBean;
import com.shlanbao.tzsc.pms.cos.spare.service.CosSparePartsServiceI;
import com.shlanbao.tzsc.pms.equ.requestRecord.service.EqpRequestRecordServiceI;
import com.shlanbao.tzsc.pms.equ.wcplan.service.EqmWheelCovelPlanServiceI;
import com.shlanbao.tzsc.pms.md.eqp.service.EquipmentsServiceI;
import com.shlanbao.tzsc.pms.md.fixCode.beans.FixCodeBean;
import com.shlanbao.tzsc.pms.md.fixCode.service.FixCodeServiceI;
import com.shlanbao.tzsc.pms.md.mat.service.MatServiceI;
import com.shlanbao.tzsc.pms.qm.outInspection.service.OutInspectionServiceI;
import com.shlanbao.tzsc.pms.sch.workorder.service.BomServiceI;
import com.shlanbao.tzsc.pms.sch.workorder.service.CraftServiceI;
import com.shlanbao.tzsc.pms.sch.workorder.service.SchProdInventoryServiceI;
import com.shlanbao.tzsc.pms.sch.workorder.service.SchWorkorderIOServiceI;
import com.shlanbao.tzsc.pms.sch.workorder.service.WorkOrderServiceI;
import com.shlanbao.tzsc.utils.params.SysEqpTypeBase;

/**
 *  [说明]：XML接口解析
 *
 * */
public class PMSXmlDataInterceptor {

	@Autowired
	private BomServiceI schWorkorderBom;
	@Autowired
	private MatServiceI matService;
	@Autowired
	private WorkOrderServiceI workOrderService;

	@Autowired
	private EquipmentsServiceI equipmentsService;
	@Autowired
	private OutInspectionServiceI outInspectionService;
	@Autowired
	private CosSparePartsServiceI cosSparePartsService;
	@Autowired
	private FixCodeServiceI fixCodeService;
	@Autowired
	private EqmWheelCovelPlanServiceI eqmWheelCovelPlanService;
	@Autowired
	private EqpRequestRecordServiceI eqpRequestRecordServiceI;
	@Autowired
	private UnitServiceI unitServiceI;
	@Autowired
	private CraftServiceI craftServiceI;
	@Autowired
	private SchProdInventoryServiceI prodInventoryServiceI;
	@Autowired
	private SchWorkorderIOServiceI workorderIOServiceI;
	@Autowired
	private LoadComboboxServiceI loadComboboxService;

	protected Logger log = Logger.getLogger(this.getClass());
	private static PMSXmlDataInterceptor instance = null;

	// 构造方法初始化
	public PMSXmlDataInterceptor() {
		if (null == matService) {
			matService = ApplicationContextUtil.getBean(MatServiceI.class);
		}
		if (null == schWorkorderBom) {
			schWorkorderBom = ApplicationContextUtil.getBean(BomServiceI.class);
		}
		if (null == workOrderService) {
			workOrderService = ApplicationContextUtil.getBean(WorkOrderServiceI.class);
		}
		if (null == eqpRequestRecordServiceI) {
			eqpRequestRecordServiceI = ApplicationContextUtil.getBean(EqpRequestRecordServiceI.class);
		}
		if (null == equipmentsService) {
			equipmentsService = ApplicationContextUtil.getBean(EquipmentsServiceI.class);
		}
		if (null == outInspectionService) {
			outInspectionService = ApplicationContextUtil.getBean(OutInspectionServiceI.class);
		}
		if (null == cosSparePartsService) {
			cosSparePartsService = ApplicationContextUtil.getBean(CosSparePartsServiceI.class);
		}
		if (null == eqmWheelCovelPlanService) {
			eqmWheelCovelPlanService = ApplicationContextUtil.getBean(EqmWheelCovelPlanServiceI.class);
		}
		if (null == fixCodeService) {
			fixCodeService = ApplicationContextUtil.getBean(FixCodeServiceI.class);
		}
		if (null == unitServiceI) {
			unitServiceI = ApplicationContextUtil.getBean(UnitServiceI.class);
		}
		if (null == craftServiceI) {
			craftServiceI = ApplicationContextUtil.getBean(CraftServiceI.class);
		}
		if (null == prodInventoryServiceI) {
			prodInventoryServiceI = ApplicationContextUtil.getBean(SchProdInventoryServiceI.class);
		}
		if (null == workorderIOServiceI) {
			workorderIOServiceI = ApplicationContextUtil.getBean(SchWorkorderIOServiceI.class);
		}
		if (null == loadComboboxService) {
			loadComboboxService = ApplicationContextUtil.getBean(LoadComboboxServiceI.class);
		}

	}

	public static PMSXmlDataInterceptor getInstance() {
		if (instance == null) {
			instance = new PMSXmlDataInterceptor();
		}
		return instance;
	}

	/**
	 * 【说明】封装返回MES成功失败详细信息
	 *
	 * @param type 1:BOM接口   2：工单撤销接口 3:工单下发
	 * @author WANCHANGHUANG
	 * @date 2019年5月8日15:58:28
	 */
	public String ContResMessage(int type, Map<String, String> mapMessages) {
		if (type == 1) {
			String DateStr = DateUtil.getNowDateTime("yyyy-MM-dd HH:mm:ss");
			//BOM下发接口
			if (mapMessages.size() > 0) {
				String message = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset>";
				//遍历MAP，凭借xml字符串
				for (Entry<String, String> entry : mapMessages.entrySet()) {
					message += "<data><Result>2</Result><ReceiveTime>" + DateStr + "</ReceiveTime><Reason>" + entry.getKey() + entry.getValue() + "</Reason></data>";
				}
				message += "</dataset>";
				return message;
			}
			return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>1</Result><ReceiveTime>" + DateStr + "</ReceiveTime><Reason>解析成功！</Reason></data></dataset>";
		} else if (type == 2) {
			//工单撤销
			if (mapMessages.size() > 0) {
				String message = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset>";
				//遍历MAP，凭借xml字符串
				for (Entry<String, String> entry : mapMessages.entrySet()) {
					message += "<data><Result>" + entry.getKey() + entry.getValue() + "</Result></data>";
				}
				message += "</dataset>";
				return message;
			}
			return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>1</Result></data></dataset>";
		} else if (type == 3) {
			//工单下发
			if (mapMessages.size() > 0) {
				String message = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset>";
				//遍历MAP，凭借xml字符串
				for (Entry<String, String> entry : mapMessages.entrySet()) {
					message += "<data><Result>2</Result><item><WorkOrderCode>" + entry.getKey() + "</WorkOrderCode><ReasonCode>" + entry.getValue() + "</ReasonCode></item></data>";
				}
				message += "</dataset>";
				return message;
			}
			return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>1</Result><item><WorkOrderCode></WorkOrderCode><ReasonCode>解析成功！</ReasonCode></item></data></dataset>";
		} else if (type == 4) {
			//物料锁定
			if (mapMessages.size() > 0) {
				String message = "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset>";
				//遍历MAP，凭借xml字符串
				for (Entry<String, String> entry : mapMessages.entrySet()) {
					message += "<data><Result>"+entry.getKey()+"</Result><Message>"+entry.getValue()+"</Message></data>";
				}
				message += "</dataset>";
				return message;
			}
			return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>1</Result><Message></Message></data></dataset>";
		}
		return null;
	}


	/**
	 * @param isSend 是否发送方
	 * @param des    日志描述
	 * @param flag   成功标志
	 * @param xml    xml文本
	 * @param remark 详细日志
	 * @Title: addLog
	 * @Description: 添加接口日志
	 * @author baoshiwei
	 * @date 2019年5月6日
	 */
	public void addLog(boolean isSend, String des, Integer flag, String xml, String... remark) {
		try {
			SysMessageQueue log = new SysMessageQueue();
			if (!isSend) {
				log.setSysReceive(1L);// 接受方
				log.setSysSend(2L);// 发送方
				log.setMsgType(0L);
			} else {
				log.setSysReceive(2L);// 接受方
				log.setSysSend(1L);// 发送方
				log.setMsgType(1L);
			}
			log.setDel(0L);

			log.setContent(xml);
			log.setDes(des);// 描述
			log.setFlag(flag);// 成功或失败
			log.setDate(new Date());
			if (remark.length > 0) {
				log.setRemark(remark[0]);
			}
			workOrderService.saveAndReturn(log);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	/**
	 * [说明]：系统握手信号
	 *
	 * @author wanchanghuang
	 * @date 2019年4月29日16:42:14
	 * @param strXml
	 */
	public String MESSendHandshakeSignal(String strXml) {
		PMSXmlDataInterceptor.getInstance().addLog(false, "系统握手信号", 1,  strXml);
		return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Response>ok</Response></data></dataset>";
	}

	/**
	 * [功能说明]：工单BOM接口
	 *
	 * @author wanchanghuang
	 * @createTime 2019年4月29日16:46:58
	 */
	public String MESSendWorkOrderBom(Document doc, String strXml) {
		try {
			if (doc == null) {
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false, "BOM接口下发", 2, strXml,"BOM接口异常,下发的xml为空！！！！");
				return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>2</Result><ReceiveTime>" + DateUtil.getNowDateTime("yyyy-MM-dd HH:mm:ss") + "</ReceiveTime><Reason>ERR：BOM接口异常,下发的xml为空！！！！</Reason></data></dataset>";
			}
			List<?> list = doc.selectNodes("//dataset/data");
			Iterator<?> WorkOrders = list.iterator();
			SchWorkorderBom schWkBom = null;
			MdMat mdMat = null;
			MdUnit mdUnit = null;
			Map<String, String> mapMessages = new HashMap<String, String>();
			// 匹配物料
			Map<String, String[]> matMap = matService.getAllMatMap();
			// 匹配单位
			Map<String, String> unitMap = Mes2DASParams.MES2DASUnit();
			while (WorkOrders.hasNext()) {
				Element ele = (Element) WorkOrders.next();
				String BOMRevision = ele.elementTextTrim("BOMRevision");//版本号
				String materialCode = ele.elementTextTrim("MaterialCode");//牌号
				String effectTime = ele.elementTextTrim("EffectTime"); // 生效日期
				Date etime = null;
				try{
					etime = DateUtil.strToDate(effectTime,"yyyy-MM-dd");
				}catch (Exception e) {
					mapMessages.put(effectTime,">>日期不能转换"+materialCode);
				}
				String[] prods= matMap.get(materialCode);
				if(prods==null || prods.length!=2) {
					mapMessages.put(materialCode,">>物料不能匹配"+materialCode);
					break;
				}

				schWorkorderBom.deleteBomByBomId(BOMRevision);
				Iterator items = ele.elementIterator("item");

                while (items.hasNext()) {
                    Element itemEle = (Element) items.next();
                    String MaterialCode = itemEle.elementTextTrim("MaterialCode"); //物料代码
                    String UOM = itemEle.elementTextTrim("UOM");//单位
                    String Quantity=itemEle.elementTextTrim("Quantity");//计划投料产量
                    String MachineCode=itemEle.elementTextTrim("MachineCode");//设备类型
                    //封装对象
                    schWkBom = new SchWorkorderBom();
                	schWkBom.setBom_lot_id(BOMRevision);
                	schWkBom.setProd(new MdMat(prods[0]));
                	schWkBom.setEqptype(MachineCode);
                	schWkBom.setEffectTime(etime);
                	schWkBom.setDel(0);
                	mdMat=new MdMat();//物料转换
                	String[] str= matMap.get(MaterialCode);
                	if(str==null || str.length!=2) {
                		mapMessages.put(MaterialCode,">>物料不能匹配"+MaterialCode);
    					break;
                	}
                    mdMat.setId(str[0]);
                	schWkBom.setMdMat(mdMat);
                	mdUnit=new MdUnit();//单位转换
                	String unitId = unitMap.get(UOM);
    				if(unitId==null || "".equals(unitId)){
    					mapMessages.put(MaterialCode,">>单位不能匹配"+UOM);
    					break;
    				}
                	mdUnit.setId(unitId);
                	schWkBom.setMdUnit(mdUnit);
                	schWkBom.setQty(StringUtil.converObj2Double(Quantity));
                	//保存
                	//插入前先查询是否已存在



					long total= schWorkorderBom.querySchWkOrderBom(schWkBom);
                	if(total==0) {
                		schWorkorderBom.addSchWkOrderBom(schWkBom);
                	} else {

					}
                }
			}
			String res = ContResMessage(1, mapMessages);
			//保存日志
			PMSXmlDataInterceptor.getInstance().addLog(false, "BOM接口下发", mapMessages.size() > 0 ? 2 : 1, strXml,res);
			//返回MES
			return res;
		} catch (Exception e) {
			e.printStackTrace();
		}
		/** 日志 2-失败  */
		PMSXmlDataInterceptor.getInstance().addLog(false, "BOM接口下发异常", 2, strXml,"ERR：BOM接口解析错误！！！");
		return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>2</Result><ReceiveTime>" + DateUtil.getNowDateTime("yyyy-MM-dd HH:mm:ss") + "</ReceiveTime><Reason>ERR：BOM接口解析错误！！！</Reason></data></dataset>";
	}

	/**
	 * [功能说明]：成品主数据接口
	 *
	 * @author wanchanghuang
	 * @createTime 2019年5月7日08:14:25
	 */
	public void MESSendFinProductData(Document doc, String strXml) {
		try {
			if (doc == null) {
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false, "成品主数据", 2, strXml ,"成品主数据异常，XML为空或者格式不正确");
			}else {
				List<?> list = doc.selectNodes("//dataset/data");
				Iterator<?> WorkOrders = list.iterator();
				MdMat mdMat = null;
				MdUnit mdUnit = null;
				MdMatType mdMatType = null;
				int success = 0;
				while (WorkOrders.hasNext()) {
					Element ele = (Element) WorkOrders.next();
					String CgtName = ele.elementTextTrim("CgtName");//卷烟牌号名称
					String CgtCode = ele.elementTextTrim("CgtCode");//卷烟牌号CODE
					if(StringUtils.isEmpty(CgtName) || StringUtils.isEmpty(CgtCode)) {
						/** 日志 1-成功 */
						PMSXmlDataInterceptor.getInstance().addLog(false,"成品主数据接口", 2,strXml,"ERR:成品主数据接口，品牌编号或品牌名称为空！");
						continue;
					}
					//封装
					mdMat = new MdMat();
					mdMat.setCode(CgtCode);//编号
					mdMat.setName(CgtName);//名称
					mdMat.setSimpleName(CgtName);//简称
					mdMat.setDes(CgtName);//备注
					mdUnit = new MdUnit();
					mdUnit.setId("1");// TODO 默认单位箱
					mdMat.setMdUnit(mdUnit);
					mdMat.setLastUpdateTime(new Date());
					mdMat.setEnable(1l);
					mdMat.setDel("0");
					mdMatType = new MdMatType();
					mdMatType.setId("1");// TODO 默认数据类型品牌1
					mdMat.setMdMatType(mdMatType);
					//保存，插入前验证是否已经存在
					long total = matService.queryMdMatType(mdMat);
					if (total == 0) { // TODO 已存在的是否需要更新？
						matService.saveMdMat(mdMat);
					}
					success ++;
				}
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false,"成品主数据接口", 1, strXml,"其接收到"+ list.size() +"条数据，保存成功" + success +"条");
			}

		}catch (Exception e) {
			PMSXmlDataInterceptor.getInstance().addLog(false,"成品主数据接口异常", 2, strXml,"接口解析异常，请核对XML数据！");
			e.printStackTrace();
		}
	}

	/**
	 * [功能说明]：滤棒 / 烟丝半成品接口
	 *
	 * @author wanchanghuang
	 * @createTime 2019年5月7日08:14:25
	 */
	public void MESSendSemiFinProductData(Document doc, String strXml) {
		String message = null;
		try {
			if (doc == null) {
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false, "半成品主数据", 2, strXml , "半成品主数据异常，XML为空或者XML格式不规范！！！");
			}else {
				List<?> list = doc.selectNodes("//dataset/data");
				Iterator<?> WorkOrders = list.iterator();
				MdMat mdMat = null;
				MdUnit mdUnit = null;
				MdMatType mdMatType = null;
				int success = 0;
				// 匹配单位
				Map<String, String> unitMap = Mes2DASParams.MES2DASUnit();
				while (WorkOrders.hasNext()) {
					Element ele = (Element) WorkOrders.next();
					String Description = ele.elementTextTrim("Description");//半成品名称
					String SemiCode = ele.elementTextTrim("SemiCode");//半成品编码
					String CgtBrandCode = ele.elementTextTrim("CgtBrandCode");//卷烟牌号CODE
					String UnitCode = ele.elementTextTrim("UnitCode");//单位
					String SemiClsCode = ele.elementTextTrim("SemiClsCode"); //类别
					mdMatType = new MdMatType();
					// 12 滤棒   09 烟丝
					if ("12".equals(SemiClsCode)){
						mdMatType.setId("14");// 滤棒半成品

					} else if("09".equals(SemiClsCode)){
						mdMatType.setId("34");// 烟丝
					} else {
						continue;
					}
					if(StringUtils.isEmpty(SemiCode) || StringUtils.isEmpty(Description)) {
						/** 日志 1-成功 */
						PMSXmlDataInterceptor.getInstance().addLog(false,"半成品主数据接口", 2, strXml,"ERR:半成品主数据接口，半成品编号或半成品名称为空！");
						continue;
					}
					//封装
					mdMat = new MdMat();
					mdMat.setCode(SemiCode);//编号
					mdMat.setName(Description);//名称
					mdMat.setSimpleName(Description);//简称
					mdMat.setDes(Description + "卷烟品牌CODE：" + CgtBrandCode);//备注
					//单位
					String unitId = unitMap.get(UnitCode);
					if (unitId == null || "".equals(unitId)) {
						 message = "ERR:烟丝/滤棒 半成品接口异常，不能找到单位" + UnitCode;
					     PMSXmlDataInterceptor.getInstance().addLog(false, "半成品主数据接口异常", 2, strXml ,message );
					     break;
					}
					mdUnit = new MdUnit();
					mdUnit.setId(unitId);
					mdMat.setMdUnit(mdUnit);
					mdMat.setLastUpdateTime(new Date());
					mdMat.setEnable(1l);
					mdMat.setDel("0");


					mdMat.setMdMatType(mdMatType);
					//保存，插入前验证是否已经存在
					long total = matService.queryMdMatType(mdMat);
					if (total == 0) {
						matService.saveMdMat(mdMat);
					}
					success ++;

				}
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false,"半成品主数据接口", 1, strXml,"其接收到"+ list.size() +"条数据，保存成功" + success +"条");
			}
		}catch (Exception e) {
			/** 日志 2-失败  */
			PMSXmlDataInterceptor.getInstance().addLog(false,"半成品主数据接口异常", 2, strXml,"接口解析异常，请核对xml数据！");
			e.printStackTrace();
		}
   }

	/**
	 * [功能说明]：卷包 / 成型 物料主数据
	 *
	 * @author wanchanghuang
	 * @createTime 2019年5月7日08:14:25
	 */
	public void MESSendPartData(Document doc, String strXml) {
		String message = null;
		try {
			if (doc == null) {
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false, "物料主数据", 2, strXml ,"物料主数据异常，XML为空或者XML格式不规范！！！");
			}else {
				List<?> list = doc.selectNodes("//dataset/data");
				Iterator<?> WorkOrders = list.iterator();
				MdMat mdMat = null;
				MdUnit mdUnit = null;
				MdMatType mdMatType = null;
				List<String> unitErr = new ArrayList<>();
				List<String> typeErr = new ArrayList<>();
				int success = 0;
				// 匹配单位
				Map<String, String> unitMap = Mes2DASParams.MES2DASUnit();
				// 物料类型（物料大类）
				Map<String, String> MatMap = Mes2DASParams.MES2DASMatType();// mescode
				while (WorkOrders.hasNext()) {
					Element ele = (Element) WorkOrders.next();
					String Name = ele.elementTextTrim("Name");//物料名称
					String Short = ele.elementTextTrim("Short");//物料简称
					String Code = ele.elementTextTrim("Code");//物料CODE
					String UnitsCode = ele.elementTextTrim("UnitsCode");//单位
					String Lcls = ele.elementTextTrim("Lcls");//物料大类

					//封装
					mdMat = new MdMat();
					mdMat.setCode(Code);//编号
					mdMat.setName(Name);//名称
					mdMat.setSimpleName(Short);//简称
					mdMat.setDes(Short);//备注
					//单位
					String unitId = unitMap.get(UnitsCode);
					if (unitId == null || "".equals(unitId)) {
						unitErr.add(Code+"-->"+UnitsCode);
						/*message = "ERR:物料主数据接口异常，不能找到单位" + UnitsCode;
						*//** 日志 2-失败  *//*
						PMSXmlDataInterceptor.getInstance().addLog(false, "物料主数据接口异常", 2, ele.asXML() , message);*/
						continue;
					}
					mdUnit = new MdUnit();
					mdUnit.setId(unitId);
					mdMat.setMdUnit(mdUnit);
					mdMat.setLastUpdateTime(new Date());
					mdMat.setEnable(1l);
					mdMat.setDel("0");
					String matTypeId="";//wu
					//物料类型 ，条透？小透不能再大类区分，碰到12只能通过小类区分
					if("12".equals(Lcls)) {
						Lcls= ele.elementTextTrim("Scls");//物料小类
						matTypeId = MatMap.get(Lcls);
					}else {
						matTypeId = MatMap.get(Lcls);
					}
					if (matTypeId == null || "".equals(matTypeId)) {
						typeErr.add(Code+"-->"+Lcls);
						/*message = "ERR:物料主数据接口异常，物料大类不能匹配到类型Lcls：" + Lcls;
						*//** 日志 2-失败  *//*
						PMSXmlDataInterceptor.getInstance().addLog(false, "物料主数据接口异常", 2, ele.asXML() , message );*/
						continue;
					}
					mdMatType = new MdMatType();
					mdMatType.setId(matTypeId);//物料大类转换成数采ID
					mdMat.setMdMatType(mdMatType);
					//保存，插入前验证是否已经存在
					long total = matService.queryMdMatType(mdMat);
					if (total == 0) {
						matService.saveMdMat(mdMat);
					}
					success ++;

				}
				/** 日志 1-成功 */
				String remark = "其接收到"+ list.size() +"条数据，保存成功" + success +"条;";
				if (unitErr.size()>0){
					remark+=unitErr.size()+"条数据单位不能匹配"+ JSONArray.fromObject(unitErr).toString();
				}
				if (typeErr.size()>0){
					remark+=typeErr.size()+"条数据物料类型不能匹配"+JSONArray.fromObject(typeErr).toString();
				}
				PMSXmlDataInterceptor.getInstance().addLog(false, "物料主数据接口", 1, strXml,remark);
			}
		} catch (Exception e) {
			/** 日志 2-失败  */
			PMSXmlDataInterceptor.getInstance().addLog(false, "物料主数据接口解析异常", 2, strXml , message);
			e.printStackTrace();
		}
	}

	/**
	 * [功能说明]：卷包/成型工单下发
	 *
	 * @author wanchanghuang
	 * @createTime 2019年5月7日08:14:25
	 */
	public String MESSendWorkOrder(Document doc, String strXml) {
		String message = null;
		try {
			if (doc == null) {
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false, "卷包工单接口下发", 2, strXml,"卷包工单接口下发异常,下发的xml为空！！！！");
				return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>2</Result><item><WorkOrderCode></WorkOrderCode><ReasonCode>ERR：卷包工单接口下发异常,下发的xml为空！！！！</ReasonCode></item></data></dataset>";
			}
			// 匹配物料
			Map<String, String[]> matMap = matService.getAllMatMap();
			// 匹配单位
			Map<String, String> unitMap = Mes2DASParams.MES2DASUnit();
			// 匹配设备
			Map<String, String> eqpMap = Mes2DASParams.MES2DASALLEqp();
			// 设备编号
            Map<String, String> eqpCodeMap=Mes2DASParams.MES2DASALLEqpCode();

			SchWorkorder schWk = null;
			MdShift mdShift = null;
			MdTeam mdTeam = null;
			MdEquipment mdEqu = null;
			MdMat mdMat = null;
			MdUnit mdUnit = null;
			int success = 0;
			Map<String, String> mapMessages = new HashMap<String, String>();
			// 获取WorkOrders节点集合
			List<?> list = doc.selectNodes("//dataset/data");
			Iterator<?> WorkOrders = list.iterator();
			while (WorkOrders.hasNext()) {
				Element ele = (Element) WorkOrders.next();
				String WorkOrderCode = ele.elementTextTrim("WorkOrderCode");// 工单编号

				if(WorkOrderCode.contains("#030")){
					continue;
				}
				String BatchCode = ele.elementTextTrim("BatchCode");// 生产批次号
				String OrderType = ele.elementTextTrim("OrderType");// 工单类型
				String ProductType = ele.elementTextTrim("ProductType");// 生产类型
				String Shift = ele.elementTextTrim("Shift");// 班次
				String TeamCode = ele.elementTextTrim("TeamCode");// 班组
				String MachineCode = ele.elementTextTrim("MachineCode");//机台
				String MaterialCode = ele.elementTextTrim("MaterialCode");//牌号
				String SequenceNo = ele.elementTextTrim("SequenceNo");// 顺序号
				String PlanQuantity = ele.elementTextTrim("PlanQuantity");// 计划产量
				String UOM = ele.elementTextTrim("UOM");// 单位
				String ProductDate = ele.elementTextTrim("ProductDate");// 计划生产日期
				String PlanStartTime = ele.elementTextTrim("PlanStartTime");//计划开始时间
				String PlanEndTime = ele.elementTextTrim("PlanEndTime");// 计划结束时间
				String BomRevision = ele.elementTextTrim("BomRevision");// 版本号
				String ParameterSetRevision = ele.elementTextTrim("ParameterSetRevision");// 工艺版本号
				//封装
				schWk = new SchWorkorder();
				schWk.setCode(WorkOrderCode);//工单编号
				schWk.setBth(BatchCode); //生产批次号
				//工单类型转换 2	包装机组  1	卷接机组 3	装封箱机 4	成型机组  5	发射机组
				/**
				 *021801	卷接机组	0218
                  021901	包装机组	0219
                  022001	滤棒成型机组	0220
                  022103	装封箱机	0221

                  MES           卷包
   0-卷包(01-卷烟  02-包装)       1-卷烟  2-包装机
                   1-成型       4-成型
                   2-制叶
                   3-制丝
                   4-封箱       3-装箱机
                   5-梗丝
                   6-烟丝
                   7-滤棒发射    5-发射机
                   8-膨丝
				 *
				 * */

				schWk.setProdType(ProductType == "1" ? 2l : 1l);//生产类型
				mdShift = new MdShift();//班次
				mdShift.setId(Shift);
				schWk.setMdShift(mdShift);

				mdTeam = new MdTeam(); //班组
				mdTeam.setId(TeamCode);
				schWk.setMdTeam(mdTeam);
				schWk.setSts(1l);//工单默认状态1：下发状态

				mdEqu = new MdEquipment();//机台
				String eqpId=eqpMap.get(MachineCode);
				if (eqpId == null || "".equals(eqpId)) {
					mapMessages.put(MachineCode, "机台号不能转换" + MachineCode);
					break;
				}

                //----------------------------------------------工单类型
                if(!StringUtils.isEmpty(OrderType)) {
                    if("0".equals(OrderType)) {
                        String eqpCode = eqpCodeMap.get(MachineCode);
                        schWk.setType(Long.valueOf(eqpCode.substring(0,1)));
                    }else if("1".equals(OrderType)) {
                        schWk.setType(4l);
                    }else if("4".equals(OrderType)) {
                        schWk.setType(3l);
                    }else if("7".equals(OrderType)) {
                        schWk.setType(5l);
                    }
                    if (schWk.getType()==null) {
                        mapMessages.put(WorkOrderCode, "工单类型不能转换" + OrderType);
                    }
                }



                mdEqu.setId(eqpId);
				schWk.setMdEquipment(mdEqu);
				//牌号
				mdMat = new MdMat();
				String[] str = matMap.get(MaterialCode);
				if (str==null || str.length != 2) {
					mapMessages.put(WorkOrderCode, "物料不能转换" + MaterialCode);
					break;
				}
				mdMat.setId(str[0]);
				schWk.setMdMat(mdMat);
				//顺序号
				schWk.setRunSeq(StringUtil.converObj2Long(SequenceNo));
				schWk.setQty(StringUtil.converObj2Double(PlanQuantity));//计划产量
				//单位
				mdUnit = new MdUnit();
				String unitId = unitMap.get(UOM);
				if (unitId == null || "".equals(unitId)) {
					mapMessages.put(WorkOrderCode, "单位不能转换" + UOM);
					break;
				}
				mdUnit.setId(unitId);
				schWk.setMdUnit(mdUnit);
				schWk.setDate(DateUtil.formatStringToDate(ProductDate, "yyyy-MM-dd"));//工单日期
				schWk.setStim(DateUtil.formatStringToDate(PlanStartTime, "yyyy-MM-dd HH:mm:ss"));//计划开始时间
				schWk.setEtim(DateUtil.formatStringToDate(PlanEndTime, "yyyy-MM-dd HH:mm:ss"));//计划结束时间
				schWk.setBomVersion(BomRevision);//版本号
				schWk.setIsNew(1l);
				schWk.setIsCheck(0l);
				schWk.setDel(0l);
				schWk.setEnable(1l);
				schWk.setIsAuto("Y");
				schWk.setParameterSetRevision(ParameterSetRevision);//工艺版本号
				if (schWk.getType()==5){
					TransmitterWorkOrderBean orderBean = new TransmitterWorkOrderBean();
					orderBean.setEqpId(schWk.getMdEquipment().getId());
					orderBean.setMaterialCode(schWk.getMdMat().getId());
					orderBean.setUnit(schWk.getMdUnit().getId());
					orderBean.setOrderType(schWk.getType()+"");
					orderBean.setDate_(schWk.getDate());
					orderBean.setDel(0);
					orderBean.setSts(1);
					orderBean.setWorkOrderCode(schWk.getCode());
					orderBean.setShift(schWk.getMdShift().getId());
					orderBean.setTeam(schWk.getMdTeam().getId());
					orderBean.setBatchCode(schWk.getBth());
					orderBean.setStim(schWk.getStim());
					orderBean.setEtim(schWk.getEtim());
					orderBean.setPlanQuantity(schWk.getQty());
					orderBean.setProductType(schWk.getProdType()+"");

					long total = workOrderService.queryTransmitterOrderByCode(orderBean.getWorkOrderCode());
					if (total==0){
						workOrderService.addFSJOrder(orderBean);
					}
				}else{
					long total = workOrderService.querySchWorkOrderByCode(schWk);
					if (total == 0) {
						//保存工单，保存前，查询是否已经插入
						workOrderService.addSchWorkOrderObj(schWk);
					}
				}
				success ++;
			}
			String res = ContResMessage(3, mapMessages);
			//保存日志
			PMSXmlDataInterceptor.getInstance().addLog(false, "卷包工单接口下发", mapMessages.size() > 0 ? 2 : 1, strXml,"其接收到"+ list.size() +"条数据，保存成功" + success +"条。" + "错误信息："+res);
			//返回MES
			return res;
		} catch (Exception e) {
			e.printStackTrace();
		}
		/** 日志 2-失败  */
		PMSXmlDataInterceptor.getInstance().addLog(false, "卷包工单接口下发异常", 2, strXml ,"ERR：卷包工单接口下发解析异常," + message);
		return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>2</Result><item><WorkOrderCode></WorkOrderCode><ReasonCode>ERR：卷包工单接口下发解析异常," + message + "</ReasonCode></item></data></dataset>";
	}

	/**
	 * [功能说明]：工单撤销接口 -同步
	 *
	 * @author wanchanghuang
	 * @createTime 2019年5月7日08:14:25
	 */
	public String MESSendOrderCancelRequest(Document doc, String strXml) {
		try {
			if (doc == null) {
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false, "工单撤销接口异常", 2, strXml,"MES下发的XML数据为空");
				return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>MES下发的XML数据为空</Result></data></dataset>";
			}
			SchWorkorder wkorder = null;
			Map<String, String> mapMessages = new HashMap<String, String>();
			List<?> list = doc.selectNodes("//dataset/data");
			Iterator<?> WorkOrders = list.iterator();
			while (WorkOrders.hasNext()) {
				Element ele = (Element) WorkOrders.next();
				String WorkOrderCode = ele.elementTextTrim("WorkOrderCode");// 工单编号
				wkorder = new SchWorkorder();
				wkorder.setCode(WorkOrderCode);
				//查询正在运行，完成的工单是否存在，如果存在，撤销失败，如果不存在，运行修改工单状态
				long total = workOrderService.querySchworkOrderByCodes(wkorder);
				if (total == 0) {
					workOrderService.updateSchWorkOrderStatus(wkorder);
				} else {
					mapMessages.put(WorkOrderCode, "该工单已经审核");
				}
			}
			String res = ContResMessage(2, mapMessages);
			//保存日志
			PMSXmlDataInterceptor.getInstance().addLog(false, "工单撤销接口下发", mapMessages.size() > 0 ? 2 : 1,
                    strXml+"----------------反馈mes信息----------------"+res);
			//返回MES
			return res;
		} catch (Exception e) {
			e.printStackTrace();
		}
		/** 日志 2-失败  */
		PMSXmlDataInterceptor.getInstance().addLog(false, "工单撤销接口下发异常", 2, strXml,"解析异常，请查看XML数据");
		return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>解析异常，请查看XML数据</Result></data></dataset>";
	}
	/**
	 * [功能说明]：物料锁定 -同步
	 *
	 * @author wanchanghuang
	 * @createTime 2019年5月7日08:14:25
	 */
	public String MESSendMaterialLock(Document doc, String strXml) {
		try {
			if (doc == null) {
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false, "物料锁定接口异常", 2, strXml,"ERR： XML为空异常");
				return "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>ERR： XML为空异常</Result><Message>/Message></data></dataset>";
			}
			MdMaterialLk wkorder = null;
			Map<String, String> mapMessages = new HashMap<String, String>();
			List<?> list = doc.selectNodes("//dataset/data");
			Iterator<?> WorkOrders = list.iterator();
			while (WorkOrders.hasNext()) {
				Element ele = (Element) WorkOrders.next();

				String MaterialCode = ele.elementTextTrim("MaterialCode");// 物料编号
				String MaterialBatchCode = ele.elementTextTrim("MaterialBatchCode");// 物料批次号
				String Type = ele.elementTextTrim("Type");// 0-解锁  1-锁定
				wkorder = new MdMaterialLk();
				wkorder.setMaterialBatchCode(MaterialBatchCode);
				wkorder.setMaterialCode(MaterialCode);
				wkorder.setType(Type);
				wkorder.setCreateDate(new Date());
				wkorder.setUpdateDate(wkorder.getCreateDate());
				/**
				 * 1.通过 type判断
				 *    0-解锁，直接修改状态
				 *    1-锁定，查看是否已存在，存在直接修改状态
				 *                     不存在，直接添加新的锁定
				 *
				 * */
				if("0".equals(Type)) {
					matService.updateMdMaterail(wkorder);
				}else if("1".equals(Type)) {
					//查询正在运行，完成的工单是否存在，如果存在，撤销失败，如果不存在，运行修改工单状态
					long total = matService.queryMdMaterailAll(wkorder);
					if(total==0) {
						//添加
						matService.addMdMaterail(wkorder);
					}else {
						//修改
						matService.updateMdMaterail(wkorder);
					}
				}
			}
			String res = ContResMessage(4, mapMessages);
			//保存日志
			PMSXmlDataInterceptor.getInstance().addLog(false, "物料锁定接口", mapMessages.size() > 0 ? 2 : 1, res + strXml);
			//返回MES
			return res;
		} catch (Exception e) {
			e.printStackTrace();
		}
		/** 日志 2-失败  */
		PMSXmlDataInterceptor.getInstance().addLog(false, "物料锁定接口异常", 2, strXml,"ERR： XML异常");
		return  "<?xml version=\"1.0\" encoding=\"UTF-8\"?><dataset><data><Result>ERR： XML异常</Result><Message>/Message></data></dataset>";
	}

	/**
	 * [功能说明]：卷接机台物料告警接口
	 * @author wanchanghuang
	 * @createTime  2019年5月15日13:00:07
	 * */
	public void MESSendEquipmentAlarm(Document doc, String strXml) {
		try {
			if (doc == null) {
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false, "卷接机台物料告警接口", 2, strXml , "[卷接机台物料告警接口异常，XML为空或者格式不正确]");
			}else {
				List<?> list = doc.selectNodes("//dataset/data");
				Iterator<?> WorkOrders = list.iterator();
				Map<String,String> map=new HashMap<String, String>();
				while (WorkOrders.hasNext()) {
					Element ele = (Element) WorkOrders.next();
					Iterator items = ele.elementIterator("item");
	                while (items.hasNext()) {
	                    Element itemEle = (Element) items.next();
	                    String CoilingNo = itemEle.elementTextTrim("CoilingNo");//卷烟牌号名称
						String Shift = itemEle.elementTextTrim("Shift");//卷烟牌号CODE
						map.put(CoilingNo, Shift);
	                }
				}
				/** 日志 1-成功 */
				PMSXmlDataInterceptor.getInstance().addLog(false,"卷接机台物料告警接口", 1, strXml);
				//推送WCT对应设备机台
				System.err.println("卷接机台物料告警接口>>>>"+map.size());
				for(Entry<String, String> k: map.entrySet()) {
					System.out.println(k.getKey()+"     "+k.getValue());
				}
			}
		}catch (Exception e) {
			PMSXmlDataInterceptor.getInstance().addLog(false,"卷接机台物料告警接口异常", 2, strXml,"接口异常");
			e.printStackTrace();
		}
	}

/******接口分割线 ************************************************************************************************/


	/**
	 * @param ftype 调用方法名称
	 * @param fstr  xml字符串
	 * @param doc   xml DOM对象
	 * @Title: alalyMESSendEquipmentToDAS
	 * @Description: 设备主数据下发（辅助设备没有工段）
	 * @author baoshiwei
	 * @date 2019年5月6日
	 */
	public void alalyMESSendEquipmentToDAS(String ftype, String fstr, Document doc) {
		try {
			MdEquipment equipment = null;
			MdEqpType mdEqpType = null;
			MdWorkshop mdWorkshop = null;
			//辅助设备
			MdAppendEquipment appendEquipment = null;
			int success = 0;
			List<MdAppendEquipment> appendEqps = new ArrayList<>();

			List<MdEquipment> eqps = new ArrayList<>();
			// 设备类型map转换
			Map<String, String> eqpTypeMap = Mes2DASParams.MES2DASEqpCategory();
			// 设备型号map转换
			Map<String, String> machineMap = Mes2DASParams.MES2DASMachineType();
			// 车间转换
			Map<String, String> workShopMap = Mes2DASParams.MES2DASWorkShop();
			// 工段对应的 数采设备信息（0：设备code 1：工单类型 2.设备类型 ）
			Map<String, String[]> workCenterMap = Mes2DASParams.MES2DASWorkCenterEQP();
			// 额定车速单位转换
			Map<String, String> rSpeedUnitMap = Mes2DASParams.MES2DASRSpeedUnit();
			// 额定产能单位转换
			Map<String, String> rCapacityUnit = Mes2DASParams.MES2DASRCapacityUnit();
			// 获取Equipments节点集合
			List<?> list = doc.selectNodes("dataset/data");
			if (list == null || list.size() < 1) {
				log.error("XML数据中不包含设备主数据信息！请核对xml数据！");
				PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, fstr, "XML数据中不包含设备主数据信息！请核对xml数据！");
				return;
			}
			Iterator<?> Equipments = list.iterator();
			while (Equipments.hasNext()) {
				//辅助设备的工段为空，用于区分主辅设备
				Element ele = (Element) Equipments.next();
				String MesEqpCode = ele.elementTextTrim("MachineryCode");// 设备编号
				String workCenter = ele.elementTextTrim("WorkCenterCode");// 工序段
				if (!StringUtil.notEmpty(MesEqpCode)) {
					log.error("设备编号不能为空！");
				}
				//辅助设备没有工段
				//主数据(发射机没有工段，需要手动录入或特殊处理)
				if (StringUtil.notEmpty(workCenter)) {
					// 根据设备编码或工段查询是否已经存在。已存在的不进行操作
					equipment = equipmentsService.getEqpByMESCodeOrWorkCenter(MesEqpCode, workCenter, true);
					if (equipment != null) {
						// 设备已经存在
						//	throw new Exception("该设备已经在卷包数采中存在！设备mes_code为" + MesEqpCode);
						System.out.println("该设备已经在卷包数采中存在！设备mes_code为" + MesEqpCode);
					}
					String[] str = workCenterMap.get(workCenter);
					if (str == null) {
						log.error("数采系统没有匹配到MES中该设备工段对应的设备信息！请在卷包数采    综合基础数据中维护！设备工段为" + workCenter);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "数采系统没有匹配到MES中该设备工段对应的设备信息！请在卷包数采    综合基础数据中维护！设备工段为" + workCenter);
						continue;
					}
					String eqpCode = str[0];
					if (!StringUtil.isInteger(eqpCode)) {
						log.error("MES系统下发的该设备工段对应的数采设备信息维护设备code错误！请在卷包数采    综合基础数据中维护！设备工段为" + workCenter);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "MES系统下发的该设备工段对应的数采设备信息维护设备code错误！请在卷包数采    综合基础数据中维护！设备工段为" + workCenter);
						continue;
					}
					String eqpName = str[3];

					//String eqpName = ele.elementTextTrim("MachineryName");// 设备名称
					String eqpDesc = ele.elementTextTrim("EquipmentLocationDes");// 设备描述
					String eqpType = ele.elementTextTrim("MachinerySClass");// 设备类别
					// 卷烟机、包装机
					eqpType = eqpTypeMap.get(eqpType);  //设备类型大类  1：卷烟机  2：保障机制   3：  装封箱机   4：成型机
					if (eqpType == null) {
						log.error("卷包数采系统没有匹配到MES设备类型！请在卷包数采    综合基础数据中维护  。该设备mes_code为" + MesEqpCode
								+ "		MES设备类型为：" + ele.elementTextTrim("MachinerySClass"));
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "卷包数采系统没有匹配到MES设备类型！请在卷包数采    综合基础数据中维护  。该设备mes_code为" + MesEqpCode
								+ "		MES设备类型为：" + ele.elementTextTrim("MachinerySClass"));
						continue;
					}
					String machineType = ele.elementTextTrim("MachineryModel");// 机型
					// ZJ17
					machineType = machineMap.get(machineType);
					if (machineType == null) {
						log.error("卷包数采系统没有匹配到MES系统该设备机型！请在卷包数采    综合基础数据中维护  。该设备mes_code为" + MesEqpCode
								+ "		MES中设备机型为：" + ele.elementTextTrim("MachineryModel"));
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "卷包数采系统没有匹配到MES系统该设备机型！请在卷包数采    综合基础数据中维护  。该设备mes_code为" + MesEqpCode
								+ "		MES中设备机型为：" + ele.elementTextTrim("MachineryModel"));
						continue;
					}
					String workshop = ele.elementTextTrim("AreaName");// 车间
					workshop = workShopMap.get(workshop);
					if (workshop == null) {
						log.error("卷包数采系统没有匹配到MES中该设备所属车间！请在卷包数采    综合基础数据中维护  。该设备mes_code为" + MesEqpCode
								+ "		MES中该设备所属车间为：" + ele.elementTextTrim("AreaName"));
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "卷包数采系统没有匹配到MES中该设备所属车间！请在卷包数采    综合基础数据中维护  。该设备mes_code为" + MesEqpCode
								+ "		MES中该设备所属车间为：" + ele.elementTextTrim("AreaName"));
						continue;
					}
					String eqpPosition = ele.elementTextTrim("EquipmentLocation");// 设备位置
					if (eqpPosition == null) {
						log.error("设备位置不能为空。且唯一！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "设备位置不能为空。且唯一！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}
					String rateSpeed = ele.elementTextTrim("MachineryRspeed");// 额定车速
					/*if (StringUtil.notNull(rateSpeed) && !StringUtil.isDouble(rateSpeed)) {
						log.error("额定车速必须为数字！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "额定车速必须为数字！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}*/
					String rateSpeedUnit = ele.elementTextTrim("RspeedUnit");// 额定车速单位
					rateSpeedUnit = rSpeedUnitMap.get(rateSpeedUnit);

					String yield = ele.elementTextTrim("MachineryRcapacity");// 额定产能
					/*if (StringUtil.notNull(yield) && !StringUtil.isDouble(yield)) {
						log.error("额定产能必须为数字！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "额定产能必须为数字！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}*/
					String yieldUnit = ele.elementTextTrim("RcapacityUnit");// 额定产能单位
					yieldUnit = rCapacityUnit.get(yieldUnit);

					String enabled = ele.elementTextTrim("Enabled");// 是否启用
					if (!StringUtil.notNull(enabled)) {
						log.error("是否启用状态不能为空！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "是否启用状态不能为空！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}
					if (enabled.equalsIgnoreCase("true")) {
						enabled = "1";
					} else {
						enabled = enabled.equals("1")?"1":"0";
					}
					String fixedAssetNum = ele.elementTextTrim("FixedCode");// 固定资产编号
					/*if (!StringUtil.notNull(fixedAssetNum)) {
						log.error("固定资产编号不能为空！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "固定资产编号不能为空！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}*/
					String manufacturingNum = ele.elementTextTrim("ManufactureNo");// 出厂编号
					/*if (!StringUtil.notNull(manufacturingNum)) {
						log.error("出厂编号不能为空！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "出厂编号不能为空！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}*/
					String approvalNum = ele.elementTextTrim("RegistrationCode");// 批准文号
					String navicertNum = ele.elementTextTrim("NavicertNum");// 准运证编号
					String usingDepartment = ele.elementTextTrim("System");// 使用部门
					String fixedAssetDate = ele.elementTextTrim("FixedTime");// 入固时间
					// yyyy-mm-dd
					Date fixedDate = DateUtil.formatStringToDate(fixedAssetDate, "yyyy-MM-dd");
					if (fixedDate == null) {
						/*log.error("入固时间不能为空，且格式为yyyy-MM-dd！错误数据设备mes_code为" + MesEqpCode + "	错误时间为："
								+ ele.elementTextTrim("FixedAssetDate"));*/
						fixedDate = new Date();
					}
					//如果不存在则新增
					if (equipment == null) {
						equipment = new MdEquipment();
					}
					mdEqpType = new MdEqpType(machineType);
					mdWorkshop = new MdWorkshop();
					mdWorkshop.setId(workshop);
					equipment.setMdEqpType(mdEqpType);
					equipment.setMdWorkshop(mdWorkshop);
					equipment.setEquipmentCode(eqpCode);
					equipment.setMesEqpCode(MesEqpCode);
					equipment.setWorkCenter(workCenter);
					equipment.setEquipmentName(eqpName);
					equipment.setEquipmentDesc(eqpDesc);
					equipment.setEquipmentPosition(eqpPosition);
					if (StringUtil.notNull(rateSpeed)) {
						equipment.setRatedSpeed(Double.valueOf(rateSpeed));
					}

					equipment.setRateSpeedUnit(rateSpeedUnit);
					if (StringUtil.notNull(yield)) {
						equipment.setYieId(Double.valueOf(yield));
					}
					equipment.setYieldUnit(yieldUnit);
					equipment.setEnabled(enabled);
					equipment.setFixedAssetNum(fixedAssetNum);
					equipment.setFixedAssetFlag("0");
					equipment.setManufacturingNum(manufacturingNum);
					equipment.setApprovalNum(approvalNum);
					equipment.setNavicertNum(navicertNum);
					equipment.setCreateTime(fixedDate);
					equipment.setUsingDepartment(usingDepartment);
					equipment.setDel("0");
					//	eqps.add(equipment);
					equipmentsService.saveOrUpdateEqp(equipment);

					PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 1, ele.asXML());
				} else {
					//辅助设备数据解析
					// 根据设备编码或工段查询是否已经存在。已存在的不进行操作
					appendEquipment = equipmentsService.getAppdependEqpByMESCodeOrWorkCenter(MesEqpCode);
					if (appendEquipment != null) {
						// 设备已经存在
						//	throw new Exception("该设备已经在卷包数采中存在！设备mes_code为" + MesEqpCode);
						System.out.println("更新MEScode设备：" + MesEqpCode);
					}
					String eqpName = ele.elementTextTrim("MachineryName");// 设备名称
					String eqpDesc = ele.elementTextTrim("EquipmentLocationDes");// 设备描述
					String eqpType = ele.elementTextTrim("MachineryLClass");// 设备类别
					// 卷烟机、包装机
					String machineType = ele.elementTextTrim("MachineryModel");// 机型
					// ZJ17
					String workshop = ele.elementTextTrim("AreaName");// 车间
					workshop = workShopMap.get(workshop);
					if (workshop == null) {
						log.error("卷包数采系统没有匹配到MES中该设备所属车间！请在卷包数采    综合基础数据中维护  。该设备mes_code为" + MesEqpCode
								+ "		MES中该设备所属车间为：" + ele.elementTextTrim("AreaName"));
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "卷包数采系统没有匹配到MES中该设备所属车间！请在卷包数采    综合基础数据中维护  。该设备mes_code为" + MesEqpCode
								+ "		MES中该设备所属车间为：" + ele.elementTextTrim("AreaName"));
						continue;
					}
					String eqpPosition = ele.elementTextTrim("EquipmentLocation");// 设备位置
					if (eqpPosition == null) {
						log.error("设备位置不能为空。且唯一！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "设备位置不能为空。且唯一！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}
					String rateSpeed = ele.elementTextTrim("MachineryRspeed");// 额定车速
					if (StringUtil.notNull(rateSpeed) && !StringUtil.isDouble(rateSpeed)) {
						log.error("额定车速必须为数字！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "额定车速必须为数字！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}
					String rateSpeedUnit = ele.elementTextTrim("RspeedUnit");// 额定车速单位
					String yield = ele.elementTextTrim("MachineryRcapacity");// 额定产能
					if (StringUtil.notNull(yield) && !StringUtil.isDouble(yield)) {
						log.error("额定产能必须为数字！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "额定产能必须为数字！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}
					String yieldUnit = ele.elementTextTrim("RcapacityUnit");// 额定产能单位
					String enabled = ele.elementTextTrim("Enabled");// 是否启用
					if (!StringUtil.notNull(enabled)) {
						log.error("是否启用状态不能为空！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "是否启用状态不能为空！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}
					/*if (enabled.equalsIgnoreCase("true")) {
						enabled = "1";
					} else {
						enabled = "0";
					}*/
					String fixedAssetNum = ele.elementTextTrim("FixedCode");// 固定资产编号
					if (!StringUtil.notNull(fixedAssetNum)) {
						log.error("固定资产编号不能为空！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "固定资产编号不能为空！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}
					String manufacturingNum = ele.elementTextTrim("ManufactureNo");// 出厂编号
					if (!StringUtil.notNull(manufacturingNum)) {
						log.error("出厂编号不能为空！错误数据设备mes_code为" + MesEqpCode);
						PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, ele.asXML(), "出厂编号不能为空！错误数据设备mes_code为" + MesEqpCode);
						continue;
					}
					String approvalNum = ele.elementTextTrim("RegistrationCode");// 批准文号
					String navicertNum = ele.elementTextTrim("NavicertNum");// 准运证编号
					String usingDepartment = ele.elementTextTrim("System");// 使用部门
					String fixedAssetDate = ele.elementTextTrim("FixedTime");// 入固时间
					// yyyy-mm-dd
					Date fixedDate = DateUtil.formatStringToDate(fixedAssetDate, "yyyy-MM-dd");
					if (fixedDate == null) {
						/*throw new Exception("入固时间不能为空，且格式为yyyy-MM-dd！错误数据设备mes_code为" + MesEqpCode + "	错误时间为："
								+ ele.elementTextTrim("FixedAssetDate"));*/
						fixedDate = new Date();
					}
					//如果不存在则新增
					if (appendEquipment == null) {
						appendEquipment = new MdAppendEquipment();
					}

					appendEquipment.setEqpType(eqpType);
					appendEquipment.setMdEqpType(machineType);
					appendEquipment.setMdWorkshop(workshop);
					appendEquipment.setEquipmentCode(null);
					appendEquipment.setMesEqpCode(MesEqpCode);
					appendEquipment.setWorkCenter(workCenter);
					appendEquipment.setEquipmentName(eqpName);
					appendEquipment.setEquipmentDesc(eqpDesc);
					appendEquipment.setEquipmentPosition(eqpPosition);
					if (StringUtil.notNull(rateSpeed)) {
						appendEquipment.setRatedSpeed(Double.valueOf(rateSpeed));
					}

					appendEquipment.setRateSpeedUnit(rateSpeedUnit);
					if (StringUtil.notNull(yield)) {
						appendEquipment.setYieId(Double.valueOf(yield));
					}

					appendEquipment.setYieldUnit(yieldUnit);
					appendEquipment.setEnabled(enabled);
					appendEquipment.setFixedAssetNum(fixedAssetNum);
					appendEquipment.setFixedAssetFlag("0");
					appendEquipment.setManufacturingNum(manufacturingNum);
					appendEquipment.setApprovalNum(approvalNum);
					appendEquipment.setNavicertNum(navicertNum);
					appendEquipment.setCreateTime(fixedDate);
					appendEquipment.setUsingDepartment(usingDepartment);
					appendEquipment.setDel("0");
					equipmentsService.saveOrUpdateAppendEqp(appendEquipment);
					//PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 1, ele.asXML());
					success ++;
				}
			}
			PMSXmlDataInterceptor.getInstance().addLog(false,"设备主数据下发", 1, fstr,"共下发" + list.size()+"条，保存成功：" + success + "条");
			loadComboboxService.initCombobox(ComboboxType.ALL);
		} catch (Exception e) {
			/** 日志 0-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "设备主数据下发", 2, fstr, "REEOR:设备主数据下发接口解析失败..." + ftype + ":" + fstr);
			System.out.println("REEOR:设备主数据下发接口解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
		}
	}

	/**
	 * @param ftype fstr  fdoc
	 * @return
	 * @throws Exception
	 * @Title: MESSendRSpeedUnitToDAS
	 * @Description: 解析并保存额定产能单位标识代码
	 * @author baoshiwei
	 * @date 2019年5月6日
	 */
	public void alalyMESSendRCapacityUnitToDAS(String ftype, String fstr, Document fdoc) {
		try {
			List<?> list = fdoc.selectNodes("dataset/data");
			MdFixCode fixCode = null;
			FixCodeBean bean = null;
			if (list == null || list.size() < 1) {
				log.error("XML数据中不包含额定产能单位信息！请核对xml数据！");
				PMSXmlDataInterceptor.getInstance().addLog(false, "额定产能单位下发", 2, fstr, "XML数据中不包含额定产能单位信息！请核对xml数据！");
				return;
			}
			Iterator<?> fixCodes = list.iterator();
			while (fixCodes.hasNext()) {
				Element ele = (Element) fixCodes.next();
				try {
					String code = ele.elementTextTrim("RCapacityUnitCode");// 设备编号
					String name = ele.elementTextTrim("RCapacityUnitName");// 工序段
					fixCode = new MdFixCode();
					fixCode.setMesCode(code);
					fixCode.setUpcode("RCapacityUnit");   // 添加上级代码
					fixCode.setDes(name);
					fixCode.setDel("0");
					bean = BeanConvertor.copyProperties(fixCode, FixCodeBean.class);

					fixCodeService.saveFixCode(fixCode, bean);
					PMSXmlDataInterceptor.getInstance().addLog(false, "额定产能单位下发", 1, ele.asXML());
				} catch (Exception e) {
					PMSXmlDataInterceptor.getInstance().addLog(false, "额定产能单位下发", 2, ele.asXML(), e.getMessage());
					System.out.println("REEOR:额定产能单位下发接口解析失败..." + ftype + ":" + ele.asXML());
					e.printStackTrace();
				}
			}
		} catch (Exception e) {
			/** 日志 0-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "额定产能单位下发", 2, fstr, e.getMessage());
			log.error("REEOR:额定产能单位下发接口解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
		}

	}

	/**
	 * @param ftype fstr  fdoc
	 * @return
	 * @Title: MESSendRSpeedUnitToDAS
	 * @Description: 解析保存额定车速标识代码
	 * @author baoshiwei
	 * @date 2019年5月6日
	 */
	public void alalyMESSendRSpeedUnitToDAS(String ftype, String fstr, Document fdoc) {
		try {
			List<?> list = fdoc.selectNodes("dataset/data");
			MdFixCode fixCode = null;
			FixCodeBean bean = null;
			if (list == null || list.size() < 1) {
				log.error("XML数据中不包含额定车速单位信息！请核对xml数据！");
				PMSXmlDataInterceptor.getInstance().addLog(false, "额定车速单位下发", 2, fstr, "XML数据中不包含额定车速单位信息！请核对xml数据！");
				return;
			}
			Iterator<?> fixCodes = list.iterator();
			while (fixCodes.hasNext()) {
				Element ele = (Element) fixCodes.next();
				try {
					String code = ele.elementTextTrim("RSpeedUnitCode");// 设备编号
					String name = ele.elementTextTrim("RSpeedUnitName");// 工序段
					fixCode = new MdFixCode();
					fixCode.setMesCode(code);
					fixCode.setUpcode("RSpeedUnit");   // 添加上级代码
					fixCode.setDes(name);
					fixCode.setDel("0");
					bean = BeanConvertor.copyProperties(fixCode, FixCodeBean.class);

					fixCodeService.saveFixCode(fixCode, bean);
					PMSXmlDataInterceptor.getInstance().addLog(false, "额定车速单位下发", 1, ele.asXML());
				} catch (Exception e) {
					PMSXmlDataInterceptor.getInstance().addLog(false, "额定车速单位下发", 2, ele.asXML(), e.getMessage());
					System.out.println("REEOR:额定车速单位下发接口解析失败..." + ftype + ":" + ele.asXML());
					e.printStackTrace();
				}
			}
			//PMSXmlDataInterceptor.getInstance().addLog(false,"额定车速单位下发", 1, fstr);
		} catch (Exception e) {
			/** 日志 0-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "额定车速单位下发", 2, fstr, e.getMessage());
			System.out.println("REEOR:额定车速单位下发接口解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
		}

	}

	/**
	 * @param ftype
	 * @param fstr
	 * @param fdoc
	 * @Title: addMesSendEquipmentWorkOrder
	 * @Description: 设备保养工单接口，解析xml,保存数据
	 * @author baoshiwei
	 * @date 2019年5月7日
	 */
	public void addMesSendEquipmentWorkOrder(String ftype, String fstr, Document fdoc) {
		try {
			List<Element> info = fdoc.selectNodes("dataset/data");
			int success = 0;
			for (Element lt : info) {
				EqmWheelCovelPlanInfo ecp = new EqmWheelCovelPlanInfo();
				String EMWorkOrderCode = lt.elementTextTrim("EMWorkOrderCode"); // 设备保养工单号
				ecp.setEqp_work_order_code(EMWorkOrderCode);
				String PlanDate = lt.elementTextTrim("PlanDate"); //计划日期
				ecp.setPlan_date(DateUtil.formatStringToDate(PlanDate, "yyyy-MM-dd"));
				String PlanStartTime = lt.elementTextTrim("PlanStartTime"); //计划起始时间
				ecp.setPlan_stime(DateUtil.formatStringToDate(PlanStartTime, "yyyy-MM-dd HH:mm:ss"));
				String Duration = lt.elementTextTrim("Duration"); //计划维护时长
				ecp.setPlan_times(Duration);
				String Shift = lt.elementTextTrim("Shift"); //班次
				ecp.setShift_id(Shift);//1. 早班  2.中班  3.晚班 0 常日班
				if ("0".equals(Shift)) {
					ecp.setShift_name("常日班");
				} else if ("1".equals(Shift)) {
					ecp.setShift_name("早班");
				} else if ("2".equals(Shift)) {
					ecp.setShift_name("中班");
				} else if ("3".equals(Shift)) {
					ecp.setShift_name("晚班");
				}
				String Planner = lt.elementTextTrim("Planner"); //制单人
				ecp.setPlan_name(Planner);
				String Equipmentcode = lt.elementTextTrim("Equipmentcode"); //设备编号
				EquipmentsBean fcb = SysEqpTypeBase.getEquipmentByMesCodeToId(Equipmentcode, true);
				if (fcb == null) {
					PMSXmlDataInterceptor.getInstance().addLog(false, "设备保养计划下发", 2, lt.asXML(), "设备号转换失败!!!");
					continue;
				}
				ecp.setEqp_id(fcb.getId());
				ecp.setEqp_name(fcb.getName());
				String MaintainaceType = lt.elementTextTrim("MaintainaceType"); //保养类别
				ecp.setType(MaintainaceType); //1. 轮保 2 润滑 3 停产检修 4   点检
				String LocationCode = lt.elementTextTrim("LocationCode"); //车间代码

				FixCodeBean bean = SysEqpTypeBase.getFixCodeByMesCode(LocationCode,"WORKSHOP0001",true);
				if (bean == null){
					PMSXmlDataInterceptor.getInstance().addLog(false, "设备保养计划下发", 2, lt.asXML(), "车间转换失败！！");
					continue;
				}
				ecp.setShop_code(bean.getCode()); //1.制丝 2.卷包 3 成型 4.动力 6.高架库queryMaintainPlan
				String CycleType = lt.elementTextTrim("CycleType"); //检验类型
				ecp.setAttr1(CycleType);//1月检，2周检，3日检,4年
				String CycleNum = lt.elementTextTrim("CycleNum"); //检验周期
				ecp.setAttr2("1");//检验周期数 （1个月，3个月，6 个月 等）
				ecp.setDel(0);
				ecp.setSh_status(0);
				//保存主数据
				eqmWheelCovelPlanService.saveByEqmWheelCovelPlanByObj(ecp);
				success ++;
				/** 日志 1-成功 */
				//PMSXmlDataInterceptor.getInstance().addLog(false, "设备保养计划下发", 1, lt.asXML());
			}
			PMSXmlDataInterceptor.getInstance().addLog(false,"设备保养计划下发", 1, fstr,"共下发" + info.size()+"条，保存成功：" + success + "条");
		} catch (Exception e) {
			/** 日志 0-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "设备保养计划下发", 2, fstr, e.getMessage());
			log.error("REEOR:设备保养计划下发解析失败..." + ftype + ":" + fstr);
		}
	}

	/**
	 * @param ftype
	 * @param fstr
	 * @param fdoc
	 * @Title: addMesSendEquipmentRepairOrder
	 * @Description: 解析保存mes下发维修呼叫工单号
	 * @author baoshiwei
	 * @date 2019年5月8日
	 */
	public void addMesSendEquipmentRepairOrder(String ftype, String fstr, Document fdoc) {
		try {
			EqpRequestRecord bean = new EqpRequestRecord();
			List<Element> info = fdoc.selectNodes("dataset/data");
			for (Element ele : info) {
				String id = StringUtil.convertObjToString(ele.elementTextTrim("FaultId"));
				bean = eqpRequestRecordServiceI.getById(id);
				bean.setOrderNo(StringUtil.convertObjToString(ele.elementTextTrim("EquipmentOrder")));
				eqpRequestRecordServiceI.saveOrUpdate(bean);
			}
			PMSXmlDataInterceptor.getInstance().addLog(false,"设备维修工单下发", 1, fstr);
		} catch (Exception e) {
			/** 日志 0-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "设备维修工单下发", 2, fstr, e.getMessage());
			e.printStackTrace();
			log.error("REEOR:设备维修工单下发解析失败..." + ftype + ":" + fstr);
		}

	}


	/**
	 * @return void
	 * @Author bsw
	 * @Description //TODO 解析保存mes下发单位数据
	 * @Date 2019-05-10 10:59
	 * @Param [ftype, fstr, fdoc]
	 **/
	public void addMesSendUnit(String ftype, String fstr, Document fdoc) {
		try {
			List<Element> info = fdoc.selectNodes("dataset/data");
			int success = 0;
			for (Element lt : info) {

				UnitBean unit = new UnitBean();
				String code = lt.elementTextTrim("Code"); // 编码
				unit.setCode(code);
				String name = lt.elementTextTrim("Name"); // 名称
				unit.setName(name);
				String notation = lt.elementTextTrim("Notation"); // 单位符号
				unit.setMesCode(notation);
				unit.setType("1");
				unit.setEnable(1L);

				//保存主数据
				List<MdUnit> mdunit = unitServiceI.getUnitByParams(unit);
				if (mdunit != null && mdunit.size() > 0) {
					unit.setId(mdunit.get(0).getId());
					unitServiceI.iEditUnit(unit);
				} else {
					unitServiceI.addUnit(unit);
				}
				/** 日志 1-成功 */
				//PMSXmlDataInterceptor.getInstance().addLog(false, "计量单位主数据下发", 1, lt.asXML());
				success ++;
			}
			PMSXmlDataInterceptor.getInstance().addLog(false,"计量单位主数据下发", 1, fstr,"共下发" + info.size()+"条，保存成功：" + success + "条");
			loadComboboxService.initCombobox(ComboboxType.ALL);
		} catch (Exception e) {
			/** 日志 0-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "计量单位主数据下发", 2, fstr, e.getMessage());
			e.printStackTrace();
			log.error("REEOR:计量单位主数据下发解析失败..." + ftype + ":" + fstr);
		}
	}

	/**
	 * @return void
	 * @Author bsw
	 * @Description //TODO 解析保存MES下发外观缺陷定义数据
	 * @Date 2019-05-13 08:54
	 * @Param [ftype, fstr, fdoc]
	 **/
	public void alalyMESSendFaultDefinition(String ftype, String fstr, Document doc) {
		try {
			// 获取格式如[{FaultName=吸阻大,FaultLevel=A,FaultType=C,FaultCode=XZD001D,FaultDesc=吸阻超标,FaultMinusScore=1.0},{...}]的字符串
			List<?> list = doc.selectNodes("dataset/data");
			if (list != null && list.size() > 0) {
				Map<String,String> ft = Mes2DASParams.MES2DASCode("OUTWARDTYPE");
				List<QmOutwardDefectItem> qmOutwardDefectItems = new ArrayList<>();
				QmOutwardDefectItem qmOutwardDefectItem = null;
				int success = 0;
				for (Iterator<?> faultItem = list.iterator(); faultItem.hasNext(); ) {
					qmOutwardDefectItem = new QmOutwardDefectItem();
					Element e = (Element) faultItem.next();
					String faultType = e.elementTextTrim("FaultType");//缺陷类型   X - 箱装 T - 条盒 B - 小盒 C - 烟支 F - 滤棒  QMOUTWAND
					if (!StringUtil.notEmpty(faultType)) {
						PMSXmlDataInterceptor.getInstance().addLog(false, "卷包成型外观缺陷定义缺陷类型不能为空！", 2, e.asXML());
						continue;
					}
					faultType = ft.get(faultType)==null?faultType:ft.get(faultType);
					qmOutwardDefectItem.setType(faultType);
					String parameterCode = e.elementTextTrim("ParameterCode");//工艺参数代码
					if (!StringUtil.notEmpty(parameterCode)) {
						PMSXmlDataInterceptor.getInstance().addLog(false, "卷包成型外观缺陷定义工艺参数代码不能为空！", 2, e.asXML());
						continue;
					}
					qmOutwardDefectItem.setParameterCode(parameterCode);
					String position = e.elementTextTrim("Position");//缺陷部位
					qmOutwardDefectItem.setPos(position);
					String faultName = e.elementTextTrim("FaultName");//缺陷名称
					if (!StringUtil.notEmpty(faultName)) {
						PMSXmlDataInterceptor.getInstance().addLog(false, "卷包成型外观缺陷定义缺陷名称不能为空！", 2, e.asXML());
						continue;
					}
					qmOutwardDefectItem.setName(faultName);
					String faultCode = e.elementTextTrim("FaultCode");//缺陷代码
					if (!StringUtil.notEmpty(faultCode)) {
						PMSXmlDataInterceptor.getInstance().addLog(false, "卷包成型外观缺陷定义缺陷代码不能为空！", 2, e.asXML());
						continue;
					}
					qmOutwardDefectItem.setCode(faultCode);
					String faultDesc = e.elementTextTrim("FaultDesc");//缺陷说明
					qmOutwardDefectItem.setDes(faultDesc);
					String faultLevel = e.elementTextTrim("FaultLevel");//缺陷等级
					if (!StringUtil.notEmpty(faultLevel)) {
						PMSXmlDataInterceptor.getInstance().addLog(false, "卷包成型外观缺陷定义缺陷等级不能为空！", 2, e.asXML());
						continue;
					}
					qmOutwardDefectItem.setLvl(faultLevel);
					String minusScore = e.elementTextTrim("MinusScore");//单位扣分值
					if (!StringUtil.isFloat(minusScore)) {
						PMSXmlDataInterceptor.getInstance().addLog(false, "卷包成型外观缺陷定义单位扣分值不能为空 且必须为数字！当前值为:" + minusScore, 2, e.asXML());
						continue;
					}
					qmOutwardDefectItem.setMinusScore(Float.valueOf(minusScore));

					qmOutwardDefectItem.setDel(0L);
					QmOutwardDefectItem qf = outInspectionService.findByCode(qmOutwardDefectItem.getCode());
					//判断是否已经存在
					if (qf != null) {
						qmOutwardDefectItem.setId(qf.getId());
						outInspectionService.saveOrUpdate(qmOutwardDefectItem);
						// 成功日志
						PMSXmlDataInterceptor.getInstance().addLog(false, "卷包成型外观缺陷定义更新！更新的缺陷代码为：" + qmOutwardDefectItem.getCode(), 1, e.asXML());
						// PMSXmlDataInterceptor.getInstance().addLog(false,"卷包成型外观缺陷定义数据已存在！已存在的缺陷代码为："+qmOutwardDefectItem.getCode(), 2, fstr);
						continue;
					}
					qmOutwardDefectItems.add(qmOutwardDefectItem);
					success ++;
				}
				outInspectionService.saveOutInspections(qmOutwardDefectItems);
				// 成功日志
				PMSXmlDataInterceptor.getInstance().addLog(false, "卷包成型外观缺陷定义下发", 1, fstr,"共下发" + list.size()+"条，保存成功：" + success + "条");
			} else {
				PMSXmlDataInterceptor.getInstance().addLog(false, "MES发送给卷包数采集的成型外观缺陷定义数据为空！", 2, fstr);
			}
		} catch (Exception e) {
			/** 日志 0-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "卷包成型外观缺陷定义下发", 2, fstr, e.getMessage());
			log.info("REEOR:卷包成型外观缺陷定义下发接口解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
		}

	}

	/**
	 * @Author bsw
	 * @Description //TODO mes 下发工单撤销确认接口
	 * @Date 2019-05-13 10:18
	 * @Param [ftype, fstr, fdoc]
	 * @return void
	 **/
	public void alalyMESSendOrderCancelConfirmToDAS(String ftype, String fstr, Document doc) {
		try {
			List<?> list = doc.selectNodes("dataset/data");
			if (list.size() < 1) {
				throw new Exception("工单撤销请求数据为空！");
			}
			Iterator<?> iterator = list.iterator();
			while (iterator.hasNext()) {
				Element ele = (Element) iterator.next();
				String workCode = ele.elementTextTrim("WorkOrderCode");// 工单号
				if (!StringUtil.notEmpty(workCode)) {
					PMSXmlDataInterceptor.getInstance().addLog(false, "撤销请求的工单号不能为空！", 2, fstr);
					continue;
				}
				String command = ele.elementTextTrim("Command");// 状态 10,确认撤销

				if (!StringUtil.notEmpty(command)) {
					PMSXmlDataInterceptor.getInstance().addLog(false, "撤销结果的状态不能为空！", 2, fstr);
					continue;
				}
				if (!StringUtil.isInteger(command)) {
					PMSXmlDataInterceptor.getInstance().addLog(false, "撤销结果的状态必须是数字且为10！", 2, fstr);
					continue;
				}

				// 查询该工单是否为 待撤销状态
				String workOrderId = workOrderService.CancelRequestWorkOrderByCode(workCode, false);
				if (workOrderId != null) {
					// 修改工单状态
					if (Integer.valueOf(command) == 10) {
						// 确认，修改工单状态为8，撤销状态
						// workOrderService.MESRequestCancelWorkOrder(workOrderId,8L);
						// 确认撤销则删除该工单相关信息。
						workOrderService.deleteOrderByCode(workOrderId);
						PMSXmlDataInterceptor.getInstance().addLog(false,"工单撤销删除工单", 1, ele.asXML());
					} else if (Integer.valueOf(command) == 14) {
						// 确认，修改工单状态为1，下发状态
						workOrderService.MESRequestCancelWorkOrder(workOrderId, 1L);
						PMSXmlDataInterceptor.getInstance().addLog(false,"工单撤销取消", 1, ele.asXML());
					}

				}
			}
			//PMSXmlDataInterceptor.getInstance().addLog(false,"工单撤销结果下发", 1, fstr);
		} catch (Exception e) {
			/** 日志 0-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false,"工单撤销结果下发", 2, fstr, e.getMessage());
			System.out.println("REEOR:工单撤销结果下发接口解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
		}
	}

	/**
	 * @Title: alalyMESSendParameterSetToDAS
	 * @Description: 解析保存mes下发工艺标准
	 * @author baoshiwei
	 * @date 2019年5月14日
	 * @param ftype
	 * @param fstr
	 * @param fdoc
	 */
	public String alalyMESSendParameterSetToDAS(String ftype, String fstr, Document fdoc) {
		try {
			// 判断物料是否存在
			// 获取物料code 和id map集合
			Map<String, String[]> matMap = matService.getAllMatMapCx();
			Map<String, String> unitMap = Mes2DASParams.MES2DASUnit();
			// 获取MaterialItem节点
			List<?> list = fdoc.selectNodes("dataset/data");
			Iterator<?> datas = list.iterator();
			SchWorkorderCraft schWorkorderCraft = null;
			int success = 0;
			while (datas.hasNext()) {
				Element ele = (Element) datas.next();
				String materialCode = ele.elementTextTrim("MaterialCode");// 牌号
				String[] mats=matMap.get(materialCode);
				if (mats == null) {
					throw new Exception("工艺标准解析该物料（牌号）编码不存在！请核对物料数据。不存在的物料编码是：" + materialCode);
				}
				String matId=mats[0];
				String parameterSetRevision = ele.elementTextTrim("ParameterSetRevision");// 版本号
				if (!StringUtil.notEmpty(parameterSetRevision)) {
					throw new Exception("工艺标准解析该版本号不能为空！请核对xml数据。该物料编码是：" + materialCode);
				}
				String effectTime = ele.elementTextTrim("EffectTime");// 生效日期
				if (!StringUtil.notEmpty(effectTime)) {
					throw new Exception("工艺标准解析该生效日期不能为空！请核对xml数据。该物料编码是：" + materialCode);
				}
				Date effectDate = DateUtil.formatStringToDate(effectTime, "yyyy-MM-dd");
				if (effectDate == null) {
					throw new Exception("工艺标准解析该生效日期格式错误！支持的日期格式为 yyyy-MM-dd请核对xml数据。该物料编码是：" + materialCode);
				}
				//String effectRemark = ele.elementTextTrim("EffectRemark");// 生效备注
				// 详细项
				List<Element> peles = ele.elements("item");
				craftServiceI.deleteByCraft(parameterSetRevision,materialCode);

				if (peles != null && peles.size() > 0) {
					for (Element element : peles) {
						String parameterCode = element.elementTextTrim("ParameterCode");// 工艺参数代码
						if (!StringUtil.notEmpty(parameterCode)) {
							throw new Exception("工艺标准解析该工艺参数代码不能为空！请核对xml数据。该物料编码是：" + materialCode);
						}
						schWorkorderCraft=craftServiceI.queryByMatAndCode(matId, parameterCode);
						if(schWorkorderCraft==null){
							schWorkorderCraft = new SchWorkorderCraft();
						}
						  String dcsType = element.elementTextTrim("DCSType");// DCS类型--cp:成品 cxcp:成型成品  rol:卷接
						if (!StringUtil.notEmpty(dcsType)) { throw new
						  Exception("工艺标准解析Dcs类型不能为空！请核对xml数据。该物料编码是：" + materialCode); }
						  schWorkorderCraft.setDcsType(dcsType);
						schWorkorderCraft.setMaterialCode(matId);
						schWorkorderCraft.setParameterSetRevision(parameterSetRevision);
						schWorkorderCraft.setEffectTime(effectDate);
						//schWorkorderCraft.setEffectRemark(effectRemark);
						schWorkorderCraft.setParameterCode(parameterCode);
						schWorkorderCraft.setOrdCode(SysEqpTypeBase.getZJCJType(parameterCode));

					//	schWorkorderCraft.setMaterialCode(materialCode);
						String parameterName = element.elementTextTrim("ParameterName");// 工艺参数名称
						if (!StringUtil.notEmpty(parameterName)) {
							throw new Exception("工艺标准解析该工艺参数名称不能为空！请核对xml数据。该物料编码是：" + materialCode);
						}
						schWorkorderCraft.setParameterName(parameterName);
						String isPCP = element.elementTextTrim("IsPCP");// 是否过程控制参数
						if (StringUtil.notEmpty(isPCP)) {
							if (isPCP.equals("true")) {
								isPCP = "0";
							} else {
								isPCP = "1";
							}
							schWorkorderCraft.setPcp(Long.valueOf(isPCP));
						}
						String isQC = element.elementTextTrim("IsQC");// 是否检验项目
						if (StringUtil.notEmpty(isQC)) {
							if (isQC.equals("true")) {
								isQC = "0";
							} else {
								isQC = "1";
							}
							schWorkorderCraft.setQc(Long.valueOf(isQC));
						}
						String pValue = element.elementTextTrim("PValue");// 置信水平下限(P值)
						if (StringUtil.notEmpty(pValue)) {
							if (StringUtil.isDouble(pValue)) {
								schWorkorderCraft.setPval(Double.valueOf(pValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数置信水平下限(P值)不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String zValue = element.elementTextTrim("ZValue");// Z值
						if (StringUtil.notEmpty(zValue)) {
							if (StringUtil.isDouble(zValue)) {
								schWorkorderCraft.setZval(Double.valueOf(zValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数Z值不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String cPKValue = element.elementTextTrim("CPKValue");// CPK值
						if (StringUtil.notEmpty(cPKValue)) {
							if (StringUtil.isDouble(cPKValue)) {
								schWorkorderCraft.setCpk(Double.valueOf(cPKValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数CPK值不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String cPValue = element.elementTextTrim("CPValue");// CP值
						if (StringUtil.notEmpty(cPValue)) {
							if (StringUtil.isDouble(cPValue)) {
								schWorkorderCraft.setCp(Double.valueOf(cPValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数CP值不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String pPValue = element.elementTextTrim("PPValue");// PP值
						if (StringUtil.notEmpty(pPValue)) {
							if (StringUtil.isDouble(pPValue)) {
								schWorkorderCraft.setPp(Double.valueOf(pPValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数PP值不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String pPKValue = element.elementTextTrim("PPKValue");// PPK值
						if (StringUtil.notEmpty(pPKValue)) {
							if (StringUtil.isDouble(pPKValue)) {
								schWorkorderCraft.setPpk(Double.valueOf(pPKValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数PPK值不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String pPMValue = element.elementTextTrim("PPMValue");// PPM值
						if (StringUtil.notEmpty(pPMValue)) {
							if (StringUtil.isDouble(pPMValue)) {
								schWorkorderCraft.setPpm(Double.valueOf(pPMValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数PPM值不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String standardValue = element.elementTextTrim("StandardValue");// 标准值
						if (StringUtil.notEmpty(standardValue)) {
							if (StringUtil.isDouble(standardValue)) {
								schWorkorderCraft.setStd(Double.valueOf(standardValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数标准值不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						} else {
							throw new Exception("工艺标准解析该工艺参数标准值不能为空！请核对xml数据。该物料编码是：" + materialCode);
						}
						String upperValue = element.elementTextTrim("UpperValue");// 标准值允差上限
						if (StringUtil.notEmpty(upperValue)) {
							if (StringUtil.isDouble(upperValue)) {
								schWorkorderCraft.setUval(Double.valueOf(upperValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数标准值允差上限不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						} else {
							throw new Exception("工艺标准解析该工艺参数标准值允差上限不能为空！请核对xml数据。该物料编码是：" + materialCode);
						}
						String lowerValue = element.elementTextTrim("LowerValue");// 标准值允差下限
						if (StringUtil.notEmpty(lowerValue)) {
							if (StringUtil.isDouble(lowerValue)) {
								schWorkorderCraft.setLval(Double.valueOf(lowerValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数标准值允差下限不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						} else {
							throw new Exception("工艺标准解析该工艺参数标准值允差下限不能为空！请核对xml数据。该物料编码是：" + materialCode);
						}
						String controlUpperValue = element.elementTextTrim("ControlUpperValue");// 控制线上限
						if (StringUtil.notEmpty(controlUpperValue)) {
							if (StringUtil.isDouble(controlUpperValue)) {
								schWorkorderCraft.setCuval(Double.valueOf(controlUpperValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数控制线上限值不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String controlLowerValue = element.elementTextTrim("ControlLowerValue");// 控制线下限
						if (StringUtil.notEmpty(controlLowerValue)) {
							if (StringUtil.isDouble(controlLowerValue)) {
								schWorkorderCraft.setClval(Double.valueOf(controlLowerValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数控制线下限值不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String warningUpperValue = element.elementTextTrim("WarningUpperValue");// 警戒线上限
						if (StringUtil.notEmpty(warningUpperValue)) {
							if (StringUtil.isDouble(warningUpperValue)) {
								schWorkorderCraft.setWuval(Double.valueOf(warningUpperValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数警戒线上限不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String warningLowerValue = element.elementTextTrim("WarningLowerValue");// 警戒线下限
						if (StringUtil.notEmpty(warningLowerValue)) {
							if (StringUtil.isDouble(warningLowerValue)) {
								schWorkorderCraft.setWlval(Double.valueOf(warningLowerValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数警戒线下限不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String uom = element.elementTextTrim("UOM");// 单位
						uom = unitMap.get(uom);
						if (uom == null) {
							throw new Exception("卷包数采没有匹配到该单位编号！请在卷包数采  综合基础数据维护中 核对		该物料编码是：" + materialCode
									+ "无法匹配到的单位为：" + element.elementTextTrim("UOM"));
						}
						String isDetermine = element.elementTextTrim("IsDetermine");// 是否需要判定不合格
						if (StringUtil.notEmpty(isDetermine)) {
							if (isDetermine.equals("true")) {
								isDetermine = "0";
							} else {
								isDetermine = "1";
							}
							schWorkorderCraft.setDtm(Long.valueOf(isDetermine));
						}
						String determineLowerValue = element.elementTextTrim("DetermineLowerValue");// 不合格下限
						if (StringUtil.notEmpty(determineLowerValue)) {
							if (StringUtil.isDouble(determineLowerValue)) {
								schWorkorderCraft.setDtmuval(Double.valueOf(determineLowerValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数不合格下限不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						String determineUppderValue = element.elementTextTrim("DetermineUppderValue");// 不合格上限
						if (StringUtil.notEmpty(determineUppderValue)) {
							if (StringUtil.isDouble(determineUppderValue)) {
								schWorkorderCraft.setDtmlval(Double.valueOf(determineUppderValue));
							} else {
								throw new Exception("工艺标准解析该工艺参数不合格上限不是数字！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						/*String parameterType = element.elementTextTrim("ParameterType");// 计数类型
						if (StringUtil.notEmpty(parameterType)) {
							if (StringUtil.isInteger(parameterType)) {
								schWorkorderCraft.setParamType(Long.valueOf(parameterType));
							} else {
								throw new Exception("工艺标准解析该工艺参数计数类型不是整数！请核对xml数据。该物料编码是：" + materialCode);
							}
						}*/
						String parameterType = element.elementTextTrim("ParameterType");// 计数类型
						if (StringUtil.notEmpty(parameterType)) {
							if (StringUtil.isInteger(parameterType)) {
								schWorkorderCraft.setParamType(Long.parseLong(parameterType));
							} else {
								throw new Exception("工艺标准解析该工艺参数计数类型格式错误！请核对xml数据。该物料编码是：" + materialCode);
							}
						}
						//删除相同牌号+版本号的工艺标准
						schWorkorderCraft.setEffectRemark(parameterSetRevision+materialCode);
						//保存新的工艺标准
						craftServiceI.saveOrUpdateCraft(schWorkorderCraft);

					}

				}
				success ++;
			}

			/** 日志 1-成功 */
			PMSXmlDataInterceptor.getInstance().addLog(false,"工艺标准下发", 1, fstr,"共下发" + list.size()+"条，保存成功：" + success + "条");
			//反馈
            Document document=DocumentHelper.createDocument();
            Element root=document.addElement("dataset");
            Element body=root.addElement("data");
            Element result=body.addElement("Result");
            result.addText("1");
            Element receiveTime=body.addElement("ReceiveTime");
            receiveTime.addText(DateUtil.formatDateToString(new Date()));
			return document.asXML();
		} catch (Exception e) {
			/** 日志 2-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false,"工艺标准下发", 2, fstr, e.getMessage());
			System.out.println("REEOR:工艺标准接口解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
			//PMSXmlDataInterceptor.getInstance().addLog(false,"工艺标准下发", 1, fstr);
            Document document=DocumentHelper.createDocument();
            Element root=document.addElement("dataset");
            Element body=root.addElement("data");
            Element result=body.addElement("Result");
            result.addText("2");
            Element reason=body.addElement("Reason");
            reason.addText(e.getMessage());
            Element receiveTime=body.addElement("ReceiveTime");
            receiveTime.addText(DateUtil.formatDateToString(new Date()));
			return document.asXML();
		}

	}


	/**
	 * @Title: alalyMESSendShiftsToDAS
	 * @Description: 解析并保存mes下发排班计划
	 * @author baoshiwei
	 * @date 2019年5月14日
	 * @param ftype
	 * @param fstr
	 * @param fdoc
	 */
	public void alalyMESSendShiftsToDAS(String ftype, String fstr, Document fdoc) {
		try {
			List<?> calendarsEle = fdoc.selectNodes("dataset/data" );
			if(calendarsEle==null || calendarsEle.size() <=0){
				throw new Exception("MES发送给卷包数采的排班信息为空 ！");
			}
			//存放日历bean
			List<SchCalendar> calendars=new ArrayList<SchCalendar>();
			//数据转换MAP
			Map<String,String>	workshopMap=Mes2DASParams.MES2DASWorkShop();
			Map<String,String>  shiftMap=Mes2DASParams.MES2DASShift();
			Map<String,String>  teamMap=Mes2DASParams.MES2DASTeam();


			SchCalendar calendar=null;
			MdShift shift=null;//班组
			MdTeam team=null;//班次
			MdWorkshop workshop=null;//车间
			Date date=null;//生产日期
			Date sTime=null;//开始时间
			Date eTime=null;//结束时间


			for (Iterator<?> cale=calendarsEle.iterator();cale.hasNext();) {
					calendar=new SchCalendar();
					Element e = (Element) cale.next();
					String endTime = e.elementTextTrim("EndTime");
					eTime=DateUtil.formatStringToDate(endTime);
					if(eTime==null){
						 throw new Exception("结束时间格式错误！要求数据格式 yyyy-MM-dd HH:mm:ss 异常数据："+endTime);
					}
					String pdate =  e.elementTextTrim("PlanDate");
					date=DateUtil.formatStringToDate(pdate,"yyyy-MM-dd");
					if(date==null){
						 throw new Exception("生产日期格式错误！要求数据格式 yyyy-MM-dd 异常数据："+pdate);
					}
					String stime =	e.elementTextTrim("StartTime");
					sTime=DateUtil.formatStringToDate(stime);
					if(sTime==null){
						 throw new Exception("开始时间格式错误！要求数据格式 yyyy-MM-dd HH:mm:ss 异常数据："+stime);
					}
					String group =	e.elementTextTrim("ShiftGroup");
					if(StringUtil.isInteger(group)){
						//需要转换
						group=teamMap.get(group);
						if(group==null){
							throw new Exception("数采系统没有匹配到MES对应的班组，请在卷包数采  综合基础数据维护中维护！	异常数据："+e.elementTextTrim("Group"));
						}
						team=new MdTeam(group);
					}
					String shiftId =e.elementTextTrim("Shift");
					if(StringUtil.isInteger(shiftId)){
						//需要转换
						shiftId=shiftMap.get(shiftId);
						if(shiftId==null){
							throw new Exception("数采系统没有匹配到MES对应的班次，请在卷包数采  综合基础数据维护中维护！	异常数据："+e.elementTextTrim("Shift"));
						}
						shift=new MdShift(shiftId);
					}
					String shopId =	e.elementTextTrim("LocationCode");
					//需要转换
					workshop=new MdWorkshop();
					shopId=workshopMap.get(shopId);
					if(shopId==null){
						throw new Exception("数采系统没有匹配到MES对应的车间！请在卷包数采  综合基础数据维护中维护！	异常数据："+e.elementTextTrim("LocationCode"));
					}
					//需要转换
					workshop.setId(shopId);
					calendar=new SchCalendar(team, shift, workshop, date, sTime, eTime, 0L);
					calendars.add(calendar);
				}

			//从小到大排序     时间排序
			Collections.sort(calendars, new Comparator<SchCalendar>(){
				@Override
				public int compare(SchCalendar o1, SchCalendar o2) {
					if(o1.getDate().getTime()-o2.getDate().getTime()>=0){
						return 1;//1 从小到大    -1  从大到小
					}else{
						return -1;
					}
				}
			});
			//删除时间段内的日历
			workOrderService.deleteCalendar(calendars.get(0),calendars.get(calendars.size()-1));
			workOrderService.batchInsertAndReturn(calendars);
			//**日志 1-成功*//
			PMSXmlDataInterceptor.getInstance().addLog(false,"排班计划下发",1,fstr);
		}catch(Exception e){
		/** 日志 2-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false,"排班计划下发", 2, fstr, e.getMessage());
		System.out.println("REEOR:排班计划接口解析失败..." + ftype + ":" + fstr);
		e.printStackTrace();
		}

	}

	/**
	 * @Title: alalyMESSendTestResultToDAS
	 * @Description: 解析保存卷包批次检验结果判定
	 * @author baoshiwei
	 * @date 2019年5月14日
	 * @param ftype
	 * @param fstr
	 * @param fdoc
	 */
	public void alalyMESSendTestResultToDAS(String ftype, String fstr, Document fdoc) {
		try {
			List<Element> info = fdoc.selectNodes("dataset/data");
			for (Element lt : info) {
				String materialCode = lt.elementTextTrim("MaterialCode");
				String batchCode = lt.elementTextTrim("BatchCode");
				String qualified = lt.elementTextTrim("Qualified");
				String remark = lt.elementTextTrim("Remark");
				String workOrderNumber = lt.elementTextTrim("WorkOrderNumber");
				String orderType = lt.elementTextTrim("OrderType");



				System.out.println("MaterialCode=="+materialCode+"-----BatchCode=="+batchCode+"------Qualified=="+qualified+"-----Remark=="+remark+"-----WorkOrderNumber=="+workOrderNumber+"-----OrderType=="+orderType);
				/** 日志 1-成功 */
				//PMSXmlDataInterceptor.getInstance().addLog(false, "卷包批次检验判定结果下发", 1, lt.asXML());

			}
			/** 日志 1-成功 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "卷包批次检验判定结果下发", 1, fstr);
		} catch (Exception e) {
			/** 日志 2-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "卷包批次检验判定结果下发", 2, fstr, "REEOR:卷包批次检验判定结果下发解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
			log.error("REEOR:卷包批次检验判定结果下发解析失败..." + ftype + ":" + fstr);
		}
	}

	/**
	 * @Title: alalyMESSendWorkorderIOToDAS
	 * @Description: 解析保存工单出入库记录
	 * @author baoshiwei
	 * @date 2019年5月16日
	 * @param ftype
	 * @param fstr
	 * @param fdoc
	 */
	public void alalyMESSendWorkorderIOToDAS(String ftype, String fstr, Document fdoc) {
		try {
			SchWorkorderIO workorderIO = null;
			List<Element> info = fdoc.selectNodes("dataset/data");
			int success = 0;
			for (Element lt : info) {
				String workorderNumber = lt.elementTextTrim("WorkorderNumber");
				String matCode = lt.elementTextTrim("MaterialCode");
				String operationTime = lt.elementTextTrim("OperationTime");
				String inoutType = lt.elementTextTrim("InoutType");
				String operator = lt.elementTextTrim("Operator");
				List<Element> itmes = lt.elements("item");
				for (Element element : itmes) {

					String materialCode = element.elementTextTrim("MaterialCode");
					List<Element> Details = element.elements("Details");
					for (Element detail : Details) {
						workorderIO = new SchWorkorderIO();
						String batchCode = detail.elementTextTrim("BatchCode");
						String quantity = detail.elementTextTrim("Quantity");
						try {
							Double qty = Double.parseDouble(quantity);
							if (inoutType.equals("5")||inoutType.equals("6")) {
								workorderIO.setQuantity(-qty);
							}else {
								workorderIO.setQuantity(qty);
							}

						}catch (Exception e){
							PMSXmlDataInterceptor.getInstance().addLog(false, "工单出入库记录下发", 2, lt.asXML(),"quantity数字格式转换失败！接收值为：" + quantity);
							continue;
						}
						String uom = detail.elementTextTrim("Uom");
						String replaceMaterial = detail.elementTextTrim("ReplaceMaterial");
						String minorQuantity = detail.elementTextTrim("MinorQuantity");
						if(minorQuantity!=null){
							try {
								Double mqty = Double.parseDouble(minorQuantity);
								workorderIO.setMinorQuantity(mqty);
							}catch (Exception e){
								PMSXmlDataInterceptor.getInstance().addLog(false, "工单出入库记录下发", 2, lt.asXML(),"minorQuantity数字格式转换失败！接收值为：" + minorQuantity);
								continue;
							}
						}

						String minorUom = detail.elementTextTrim("MinorUom");
						String consumeTime = detail.elementTextTrim("ConsumeTime");

						workorderIO.setWorkorderNumber(workorderNumber);
						workorderIO.setMatCode(matCode);
						if (operationTime!=null){
							try {
								workorderIO.setOperationTime(DateUtil.formatStringToDate(operationTime, "yyyy-MM-dd HH:mm:ss"));
							} catch (Exception e2) {
								PMSXmlDataInterceptor.getInstance().addLog(false, "工单出入库记录下发", 2, lt.asXML(),"日期格式转换失败！格式为：yyyy-MM-dd HH:mm:ss  实际："+operationTime);
								continue;
							}
						}

						workorderIO.setInOutType(inoutType);
						workorderIO.setOperator(operator);
						workorderIO.setMaterialCode(materialCode);
						workorderIO.setBatchCode(batchCode);

						workorderIO.setUom(uom);
						workorderIO.setReplaceMaterial(replaceMaterial);

						workorderIO.setMinorUom(minorUom);
						if (consumeTime!=null){
							try {
								workorderIO.setConsumeTime(DateUtil.formatStringToDate(consumeTime, "yyyy-MM-dd HH:mm:ss"));
							} catch (Exception e2) {
								PMSXmlDataInterceptor.getInstance().addLog(false, "工单出入库记录下发", 2, lt.asXML(),"日期格式转换失败！格式为: yyyy-MM-dd HH:mm:ss 实际："+consumeTime);
								continue;
							}
						}

						workorderIOServiceI.addWorkorderIO(workorderIO);
					}

				}

				/** 日志 1-成功 */
//				PMSXmlDataInterceptor.getInstance().addLog(false, "工单出入库记录下发", 1, lt.asXML());
				success ++;
			}
			/** 日志 1-成功 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "工单出入库记录下发", 1, fstr,"共下发" + info.size()+"条，保存成功：" + success + "条");
		} catch (Exception e) {
			/** 日志 2-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "工单出入库记录下发", 2, fstr, "REEOR:工单出入库记录下发解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
			log.error("REEOR:工单出入库记录下发解析失败..." + ftype + ":" + fstr);
		}
	}

	/**
	 * @Title: alalyMESSendProdInventoryToDAS
	 * @Description: 解析保存成品入库记录
	 * @author baoshiwei
	 * @date 2019年5月16日
	 * @param ftype
	 * @param fstr
	 * @param fdoc
	 */
	public void alalyMESSendProdInventoryToDAS(String ftype, String fstr, Document fdoc) {
		try {
			List<Element> info = fdoc.selectNodes("dataset/data");
			SchProdInventory prodInventory = null;
			int success = 0;
			for (Element lt : info) {
				String materialCode = lt.elementTextTrim("MaterialCode");
				List<Element> items = lt.elements("item");
				for (Element e : items) {
					prodInventory = new SchProdInventory();
					prodInventory.setMaterialCode(materialCode);
					String traceCode = e.elementTextTrim("TraceCode");
					String yhgcm = e.elementTextTrim("YHGCM");
					String time = e.elementTextTrim("Time");
					prodInventory.setTraceCode(traceCode);
					prodInventory.setYhgcm(yhgcm);
					try {
						prodInventory.setTime(DateUtil.formatStringToDate(time, "yyyy-MM-dd HH:mm:ss"));
					} catch (Exception e2) {
						PMSXmlDataInterceptor.getInstance().addLog(false, "成品入库记录下发", 2, lt.asXML(),"日期格式转换失败！格式为：yyyy-MM-dd HH:mm:ss  实际："+time);
						continue;
					}
					prodInventoryServiceI.addProdInventory(prodInventory);
				}
				/** 日志 1-成功 */
				//PMSXmlDataInterceptor.getInstance().addLog(false, "成品入库记录下发", 1, lt.asXML());
				success ++;

			}
			/** 日志 1-成功 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "成品入库记录下发", 1, fstr,"共下发" + info.size()+"条，保存成功：" + success + "条");
		} catch (Exception e) {
			/** 日志 2-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "成品入库记录下发", 2, fstr, "REEOR:成品入库记录下发解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
			log.error("REEOR:成品入库记录下发解析失败..." + ftype + ":" + fstr);
		}
	}

	/**
	 * [功能说明]在线自检，巡检，成品，成型成品  共用方法
	 *     反馈成功，修改工单状态
	 *
	 * */
	public void updateQmOLinkCheck(String olid,String param) {
		fixCodeService.updateQmOLinkCheck(olid,param);
	}


	/**
	 * [功能说明]修改外观数据自动反馈  共用方法
	 *     反馈成功，修改工单状态
	 * */
	public void updateQmOutWard(String olid,String sts,boolean flag) {
		try {
			fixCodeService.updateQmOutWard(olid,sts,flag);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

    public void alalyMESSendSparePartsToDAS(String ftype, String fstr, Document fdoc) {
		try {
			// 匹配单位
			Map<String, String> unitMap = Mes2DASParams.MES2DASUnit();
			List<Element> info = fdoc.selectNodes("dataset/data");
			CosSparePartsBean spareParts = null;

			for (Element lt : info) {
				String EMWorkOrderCode = lt.elementTextTrim("EMWorkOrderCode");
				List<Element> items = lt.elements("item");
				for (Element e : items) {
					spareParts = new CosSparePartsBean();

					String PartCode = e.elementTextTrim("PartCode");
					String PartName = e.elementTextTrim("PartName");
					String Quantity = e.elementTextTrim("Quantity");
					String Unit = e.elementTextTrim("Unit");
					String Remark = e.elementTextTrim("Remark");

					spareParts.setSpareCode(PartCode);

					// 查询些备件是否存在数据库中
					List<CosSparePartsBean> cosSparePartsBeans = cosSparePartsService.queryListByBeans(spareParts);
					// 备件存在则更新库存
					if (cosSparePartsBeans!=null && cosSparePartsBeans.size()>0){
						spareParts = cosSparePartsBeans.get(0);
						spareParts.setNumber((Integer.parseInt(spareParts.getNumber())+Integer.parseInt(Quantity))+"");
					// 不存在则新增
					} else {
						spareParts.setName(PartName);
						spareParts.setRemark(Remark);
						String uom = unitMap.get(Unit);
						if (uom == null) {
							throw new Exception("卷包数采没有匹配到该单位编号！请在卷包数采  综合基础数据维护中 核对"
									+ "无法匹配到的单位为：" + Unit);
						}
						spareParts.setUnitId(uom);
						spareParts.setNumber(Quantity);
					}
					cosSparePartsService.saveOrUpdateBean(spareParts);
				}
			}
			/** 日志 1-成功 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "备件出库记录下发", 1, fstr);
		} catch (Exception e) {
			/** 日志 2-失败 */
			PMSXmlDataInterceptor.getInstance().addLog(false, "备件出库记录下发", 2, fstr, "REEOR:备件出库记录下发解析失败..." + ftype + ":" + fstr);
			e.printStackTrace();
			log.error("REEOR:备件出库记录下发解析失败..." + ftype + ":" + fstr);
		}
    }
}