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);
|
}
|
}
|
}
|
