Jcdm042-Mes-Module-One.git

			@@ -2,13 +2,14 @@


			import cn.hutool.core.collection.CollUtil;
			import cn.hutool.core.date.DateUtil;
			import cn.hutool.core.util.ObjectUtil;
			import cn.hutool.core.util.StrUtil;
			import cn.hutool.http.HttpRequest;
			import cn.hutool.http.HttpResponse;
			import cn.hutool.json.JSONObject;
			import cn.hutool.json.JSONUtil;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.jcdm.common.utils.StringUtils;
			import com.jcdm.common.core.domain.AjaxResult;
			import com.jcdm.framework.websocket.WebSocketUsers;
			import com.jcdm.main.constant.Constants;
			import com.jcdm.main.da.collectionParamConf.domain.DaCollectionParamConf;
			@@ -17,11 +18,10 @@
			import com.jcdm.main.da.paramCollection.service.IDaParamCollectionService;
			import com.jcdm.main.da.passingStationCollection.domain.DaPassingStationCollection;
			import com.jcdm.main.da.passingStationCollection.service.IDaPassingStationCollectionService;
			import com.jcdm.main.da.testDeviceInterface.domain.DaTestDeviceInterface;
			import com.jcdm.main.da.testDeviceInterface.service.IDaTestDeviceInterfaceService;
			import com.jcdm.main.da.testDeviceInterfaceTemp.domain.DaTestDeviceInterfaceTemp;
			import com.jcdm.main.da.testDeviceInterfaceTemp.service.IDaTestDeviceInterfaceTempService;
			import com.jcdm.main.om.productionOrde.domain.OmProductionOrdeInfo;
			import com.jcdm.main.om.productionOrde.service.IOmProductionOrdeInfoService;
			import com.jcdm.main.plcserver.conf.OPCElement;
			import com.jcdm.main.plcserver.util.TimeUtil;
			import com.jcdm.main.restful.factoryMes.service.RestfulService;
			import com.jcdm.main.restful.qingYan.doman.ChildVO;
			@@ -30,54 +30,29 @@
			import com.kangaroohy.milo.runner.subscription.SubscriptionCallback;
			import com.kangaroohy.milo.service.MiloService;
			import lombok.extern.slf4j.Slf4j;
			import org.slf4j.Logger;
			import org.slf4j.LoggerFactory;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			import org.springframework.stereotype.Component;
			import org.springframework.web.bind.annotation.GetMapping;

			import javax.websocket.Session;
			import java.text.SimpleDateFormat;
			import java.time.Instant;
			import java.util.*;
			import java.util.concurrent.CompletableFuture;
			import java.util.stream.Collectors;


			@Slf4j
			@Component
			public class OPCUaSubscription implements SubscriptionCallback {

			private static final Logger logger = LoggerFactory.getLogger("sys-user");
			public static SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

			public SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

			//新自动工站
			public List<String> automaticList = Arrays.asList("OP280","OP310A","OP310B", "OP300A","OP300B", "OP320A","OP320B", "OP340A","OP340B", "OP350A","OP350B", "OP360","OP365","OP370", "OP390", "OP470");

			//采集模组工位 ModuleCode
			public List<String> moduleCodeList = Arrays.asList("OP300A","OP310A","OP310B","OP300B","OP320A","OP320B","OP340A","OP340B","OP365", "OP350A", "OP350B", "OP330");

			//区分模组型号工位
			public List<String> distinguishingModules = Arrays.asList("OP300","OP310", "OP340", "OP350", "OP330");

			//区分小车码
			public List<String> agvId = Arrays.asList("OP360", "OP390", "OP470","OP280");


			//区分pack型号的工位
			public List<String> packIdList = Arrays.asList("OP280","OP360","OP390","OP470");

			//测试设备手动工位
			public List<String> testList = Arrays.asList("OP430-1","OP430-2","OP430-3","OP430-4","OP480-1","OP480-2","OP480-3","OP440");


			//空的
			public List<String> nullList = Arrays.asList("OP250","OP260");


			public static MiloService miloService;

			Map<String, Session> map = WebSocketUsers.getUsers();
			public static MiloService miloService;

			public IDaPassingStationCollectionService daPassingStationCollectionService;

			public static IDaPassingStationCollectionService daPassingStationCollectionService;

			public static IDaCollectionParamConfService collectionParamConfService;

			@@ -85,538 +60,947 @@

			public static IOmProductionOrdeInfoService omProductionOrdeInfoService;

			private static IDaTestDeviceInterfaceService daTestDeviceInterfaceService;
			public static IDaTestDeviceInterfaceTempService daTestDeviceInterfaceTempService;

			/* @Value("${orderLineUrl}")
			private static String orderLineUrl;*/

			public OPCUaSubscription(MiloService miloService,
			IDaPassingStationCollectionService daPassingStationCollectionService,
			IDaCollectionParamConfService collectionParamConfService,
			IDaParamCollectionService daParamCollectionService,
			IOmProductionOrdeInfoService omProductionOrdeInfoService,
			IDaTestDeviceInterfaceService daTestDeviceInterfaceService) {
			IDaTestDeviceInterfaceTempService daTestDeviceInterfaceTempService) {
			OPCUaSubscription.miloService = miloService;
			this.daPassingStationCollectionService = daPassingStationCollectionService;
			OPCUaSubscription.daPassingStationCollectionService = daPassingStationCollectionService;
			OPCUaSubscription.collectionParamConfService = collectionParamConfService;
			OPCUaSubscription.daParamCollectionService = daParamCollectionService;
			OPCUaSubscription.omProductionOrdeInfoService = omProductionOrdeInfoService;
			OPCUaSubscription.daTestDeviceInterfaceService = daTestDeviceInterfaceService;
			OPCUaSubscription.daTestDeviceInterfaceTempService = daTestDeviceInterfaceTempService;
			}


			@Override
			public void onSubscribe(String identifier, Object value) {

			logger.info("地址："+identifier+"值："+value);
			log.info("地址："+identifier+"值："+value);
			try {
			if(null != value && Integer.valueOf(value.toString())!= 0) {
			if(null != value && !Constants.ZERO.equals(value.toString())) {
			String[] nodes = identifier.split("[.]");
			String thoroughfare = nodes[0];//通道
			String device = nodes[1];//设备
			String tab = nodes[2];//标记
			String tabVlaue = value.toString();//地址值
			String valueString = value.toString();//地址值

			if (("RecordData").equals(tab)) {
			String recordDataDoneValue = "";
			CompletableFuture<Void> cp1 = CompletableFuture.runAsync(() -> {
			subHandle(thoroughfare,device,tab,valueString);
			});

			if("1".equals(tabVlaue)){

			//请求工单
			// if(device.equals("OP230")){
			// getFactoryOrder("OP230");
			// }

			//自动工位
			if(automaticList.stream().anyMatch(s -> s.equals(device))){
			//plc给我们一个模组码，拿模组码校验出型号
			if(moduleCodeList.stream().anyMatch(s -> s.equals(device))) {
			String RecordDataDoneAddress = thoroughfare + "." + device + ".RecordDataDone";
			//读模组码
			Object moduleCode = miloService.readFromOpcUa(thoroughfare + "." + device + ".ModuleCode").getValue();
			if(device.equals("OP365")){
			Object moduleCodeA = miloService.readFromOpcUa(thoroughfare + "." + device + ".ModuleCodeA").getValue();
			Object moduleCodeB = miloService.readFromOpcUa(thoroughfare + "." + device + ".ModuleCodeB").getValue();
			if(moduleCodeA!=null && moduleCodeB!=null){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(11).build());
			}else {
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(12).build());
			}
			return;
			}

			if(moduleCode!=null){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(11).build());
			}else {
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(12).build());
			}
			}else {
			if(agvId.stream().anyMatch(s -> s.equals(device))){
			Object agvIdObject = miloService.readFromOpcUa(thoroughfare + "." + device + ".AGVID").getValue();
			//agvId 小车码是否为空
			if(agvIdObject!=null){
			String PACKCode = thoroughfare + "." + device + ".MPACKCode";
			OmProductionOrdeInfo one = omProductionOrdeInfoService.getOne(new LambdaQueryWrapper<OmProductionOrdeInfo>().eq(OmProductionOrdeInfo::getTrolleyYard, agvIdObject.toString()));
			//小车码查找工单是否为空
			if(one!=null){
			String packId = one.getProductNum();
			miloService.writeToOpcUa(ReadWriteEntity.builder().identifier(PACKCode).value(packId).build());
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(11).build());
			}else {
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(12).build());
			}
			}else {
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(12).build());
			}

			}else {
			String RecordDataDoneAddress = thoroughfare + "." + device + ".RecordDataDone";
			Object packCodeObject = miloService.readFromOpcUa(thoroughfare + "." + device + ".PACKCode").getValue();
			if(packCodeObject!=null){
			//pack 如果区分型号的话就要处理
			//记录数据完成
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(11).build());
			}else {
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(12).build());
			}
			}
			}
			}else {
			//手动工位处理逻辑
			// if (map.containsKey(device)){
			WebSocketUsers.sendMessageToUserByText(map.get(device), "IN");
			String RecordDataDoneAddress = thoroughfare + "." + device + ".RecordDataDone";
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(11).build());
			// }
			}


			}else if("2".equals(tabVlaue)){
			if(automaticList.stream().anyMatch(s -> s.equals(device))){
			//自动工位
			//出站保存数据
			outSaveDate(thoroughfare,device);
			//记录数据完成
			/*String RecordDataDoneAddress = thoroughfare + "." + device + ".RecordDataDone";
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(Integer.valueOf(recordDataDoneValue)).build());*/
			}else {
			//手动工位
			// if(device.contains("OP330")){
			// String str = device.substring(0,5);
			// WebSocketUsers.sendMessageToUserByText(map.get(str), "END");
			// }else {
			WebSocketUsers.sendMessageToUserByText(map.get(device), "END");
			// }
			if(testList.stream().anyMatch(s -> s.equals(device))){
			String RecordDataDoneAddress = thoroughfare + "." + device + ".RecordDataDone";
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(21).build());
			// Object packCodeObject = miloService.readFromOpcUa(thoroughfare + "." + device + ".ModuleCode").getValue();
			// DaTestDeviceInterface deviceInterfaceOne = null;
			//
			// if (ObjectUtil.isNotNull(packCodeObject)) {
			// String modelCode = packCodeObject.toString();
			// deviceInterfaceOne = daTestDeviceInterfaceService.getOne(new LambdaQueryWrapper<DaTestDeviceInterface>()
			// .eq(DaTestDeviceInterface::getProductNum, modelCode)
			// .eq(DaTestDeviceInterface::getStationCode, device));
			// }
			//
			// if (deviceInterfaceOne != null && "1".equals(deviceInterfaceOne.getTotalResult())) {
			// writeToOpc(RecordDataDoneAddress, (short) 21);
			// } else {
			// writeToOpc(RecordDataDoneAddress, (short) 22);
			// }
			// writeToOpc(RecordDataDoneAddress, (short) 21);
			}


			}
			}else {
			System.out.println("^");
			}
			}
			//保存拧紧数据
			else if (("AngleResult").equals(tab)) {
			if("1".equals(tabVlaue)\|\|"2".equals(tabVlaue)){
			List<String> list = new ArrayList<>();
			String[] suffixes = {"Torque", "Angle", "TorqueResult", "AngleResult"};

			for (String suffix : suffixes) {
			String string = thoroughfare + "." + device + "." + suffix;
			list.add(string);
			}
			List<ReadWriteEntity> list1 = miloService.readFromOpcUa(list);
			List<Object> collect = list1.stream().map(ReadWriteEntity::getValue).collect(Collectors.toList());
			String joinedString = String.join(",", collect.toString());
			WebSocketUsers.sendMessageToUserByText(map.get(device), TightenTheConversionOkNg(joinedString));
			if(device.contains("270") \|\| device.contains("260")){
			logger.info("读取到工位{}的Scaner数据：{}",device,TightenTheConversionOkNg(joinedString));
			}
			}
			}
			}
			} catch (Exception e) {
			logger.info("订阅方法报错:{}"+e.getMessage());
			logger.error("订阅方法报错",e);
			log.error(e.getMessage());
			}
			}



			/**
			* 获取SNCode
			*/
			public String getSNCode(){
			String SNCode = "";
			return SNCode;
			}

			/**
			* 出站保存数据
			*/
			public void outSaveDate(String thoroughfare,String device) {
			String snCode = "";
			String result = "";
			String read = thoroughfare + "." + device + ".";

			try {
			if(nullList.stream().noneMatch(s -> s.equals(device))){//删除……………………………………………………
			if(moduleCodeList.stream().anyMatch(s -> s.equals(device))){
			read = read + "ModuleCode";
			}else {
			read = read + "PACKCode";
			public void subHandle(String thoroughfare,String device,String tab,String valueString){
			try{
			if (Constants.RECORD_CHECK_CODE.equals(tab)){//电芯校验
			if (Constants.ONE.equals(valueString)){
			Integer scanResult = 11;
			if (Constants.OP010.equals(device)){
			//OP010工位电芯条码校验\|\|OP030工位电芯条码校验
			Object value1 = miloService.readFromOpcUa(thoroughfare + "." + device + ".Scaner").getValue();
			if (ObjectUtil.isNotNull(value1)){
			String keyCode = value1.toString();
			log.info("读取到工位{}的Scaner数据：{}",device,keyCode);
			//仅校验长度是否合格
			// List<KeyCodeCheck> collect = keyCodeCheckService.list().stream().filter(x -> x.getKeyCode().contains(keyCode)).collect(Collectors.toList());
			// if (CollUtil.isNotEmpty(collect)){
			// scanResult = 11;
			// }
			}
			}else if(Constants.OP030.equals(device)){
			Object value1 = miloService.readFromOpcUa(thoroughfare + "." + device + ".Scaner").getValue();//电芯码
			if (ObjectUtil.isNotNull(value1)){
			String cellCode = value1.toString();
			scanResult = 11;
			//反馈电芯ocv检测结果,这里不用再进行检测，只要码没问题就可以了
			/*boolean b = OCVResultFeedBack(thoroughfare, device,cellCode);//对替换电芯校验
			//四个电芯的状态
			if (b){
			scanResult = 11;
			}else {
			scanResult = 12;
			}*/
			}else {
			scanResult = 12;
			}
			}
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".ScanerResult1").value(scanResult).build());
			log.info("写入到工位{}的ScanerResult1数据：{}",device,scanResult);
			}
			}
			if(device.equals("OP365")){
			try {
			saveStationInfo365(thoroughfare,device);
			}catch (Exception e){
			e.printStackTrace();
			}else if (Constants.RECORD_SN.equals(tab)){//求下发模组码请9
			if (Constants.ONE.equals(valueString)){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordSNDone").value(1).build());//没有要生产的工单
			}
			}else {
			snCode = miloService.readFromOpcUa(read).getValue().toString();
			}else if (Constants.RECORD_DATA.equals(tab)){//出入站
			if (Constants.ONE.equals(valueString)){//入站
			//1:告知MES托盘已到站，请求下发进站状态
			if (Constants.OP030.equals(device)){
			//反馈电芯ocv检测结果
			boolean b = OCVResultFeedBack(thoroughfare, device);//进站对4个电芯校验
			//四个电芯的状态
			if (b){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(11).build());
			log.info("写入到工位{}的RecordDataDone数据：{}",device,11);
			}else {
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(12).build());
			log.info("写入到工位{}的RecordDataDone数据：{}",device,12);
			}
			} else if(Constants.OP100_1.equals(device) \|\| Constants.OP100_2.equals(device)){
			//1、进站PLC给产品类型，MES读取产品类型
			Object productTypeObjcet = miloService.readFromOpcUa(thoroughfare + "." + device + ".ProductType").getValue();//产品类型
			if (ObjectUtil.isNotNull(productTypeObjcet)){
			String productType = productTypeObjcet.toString();//产品类型
			String materialCode = Constants.materialMap.get(productType);
			//调用工厂MES，保存到数据库,并且将工单传给PLC
			CompletableFuture<Void> cp1 = CompletableFuture.runAsync(() -> {
			receivingWorkOrders(thoroughfare, device,materialCode);
			});
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(11).build());
			log.info("写入到工位{}的RecordDataDone数据：{}",device,11);
			}else{
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(12).build());
			}

			if(null == snCode \|\| "".equals(snCode)){
			String RecordDataDoneAddress = thoroughfare + "." + device + ".RecordDataDone";
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(Integer.valueOf("22")).build());
			}else{

			String workOrderNo = "";
			String productCode = "";
			//2、保存过站采集数据
			Object orderNumberObject = miloService.readFromOpcUa(thoroughfare + "." + device + "." + "WorkOrderNumber").getValue();
			if(orderNumberObject!=null){
			workOrderNo = orderNumberObject.toString();
			}else if (Constants.OP150.contains(device)){//人工工位
			Object modulCodeObjcet = miloService.readFromOpcUa(thoroughfare + "." + device + ".ModuleCode").getValue();
			if (ObjectUtil.isNull(modulCodeObjcet)){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(12).build());
			}else{
			String productNum = modulCodeObjcet.toString();
			//将产品SN发送到前台
			productNum = "productNum,"+ productNum;
			WebSocketUsers.sendMessageToUserByText(map.get(device), productNum);
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(11).build());
			}
			}else if (Constants.ModuleList.contains(device)){//有模组码的工位
			Object modulCodeObjcet = miloService.readFromOpcUa(thoroughfare + "." + device + ".ModuleCode").getValue();
			if (ObjectUtil.isNull(modulCodeObjcet)){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(12).build());
			}else{
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(11).build());
			}
			}

			Object productCodeObject = miloService.readFromOpcUa(thoroughfare + "." + device + "." + "ProductType").getValue();
			if(productCodeObject!=null){
			productCode = productCodeObject.toString();
			else {
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(11).build());
			log.info("写入到工位{}的RecordDataDone数据：{}",device,11);
			}
			}else if (Constants.TWO.equals(valueString)){//出站
			//分段010-065段
			if (Constants.OP010.equals(device)){
			//010工位无过站记录，只给放行信号
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(21).build());
			log.info("写入到工位{}的RecordDataDone数据：{}",device,21);
			}else if (Constants.OP020_OP090.contains(device)){
			Integer result = 21;
			//读取电芯码
			List<String> cellCodeList = readCellCodeList(thoroughfare, device);
			if(ObjectUtil.isNull(cellCodeList) \|\| cellCodeList.size() != 4 ){
			result = 23;
			}else{
			String cellCode1 = cellCodeList.get(0);
			String cellCode2 = cellCodeList.get(1);
			String cellCode3 = cellCodeList.get(2);
			String cellCode4 = cellCodeList.get(3);
			if ((!cellCode1.isEmpty() && cellCode2.isEmpty()) \|\| (cellCode1.isEmpty() && !cellCode2.isEmpty())
			\|\| (!cellCode3.isEmpty() && cellCode4.isEmpty()) \|\| (!cellCode4.isEmpty() && cellCode3.isEmpty())) {
			result = 23;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(result).build());
			return;
			}

			saveStationInfo(snCode,thoroughfare,device,workOrderNo,productCode);
			//3、保存参数采集数据
			List<DaParamCollection> daParamCollectionList = SaveParamData(snCode,thoroughfare,device,workOrderNo,productCode);
			result = savePassingStation(thoroughfare, device,cellCodeList);//保存过站
			if(result == 21) {
			if(Constants.OP030.contains(device)){
			daTestDeviceInterfaceTempService.deleteDaTestDeviceInterfaceTempByProductNum(cellCode1);
			daTestDeviceInterfaceTempService.deleteDaTestDeviceInterfaceTempByProductNum(cellCode2);
			daTestDeviceInterfaceTempService.deleteDaTestDeviceInterfaceTempByProductNum(cellCode3);
			daTestDeviceInterfaceTempService.deleteDaTestDeviceInterfaceTempByProductNum(cellCode4);
			}
			result = saveParamCollection(device,cellCodeList);//保存参数，发送工厂MES
			}

			//如果是末尾工站要报工
			if(device.equals("OP500")){
			RestfulService.getWorkReportResultFeedback(snCode,device,format.format(new Date()));
			//1、更新工单信息
			updateOrderInfo(snCode);
			}
			}

			try{
			daParamCollectionService.automaticWorkstationPushGeelycvMesFeedback(snCode,device,daParamCollectionList);
			}catch (Exception e){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(result).build());
			log.info("写入到工位{}的RecordDataDone数据：{}",device,result);
			} else if (Constants.OP100_OP150.contains(device)){//人工工位
			WebSocketUsers.sendMessageToUserByText(map.get(device), "END");
			} else {
			Integer result = 21;
			//Object productTypeObjcet = miloService.readFromOpcUa(thoroughfare + "." + device + ".ProductType").getValue();//产品类型
			Object modulCodeObjcet = miloService.readFromOpcUa(thoroughfare + "." + device + ".ModuleCode").getValue();
			if (ObjectUtil.isNull(modulCodeObjcet)){
			result = 23;
			}else{
			String moduleCode = modulCodeObjcet.toString();
			Object stationStatusObjcet = miloService.readFromOpcUa(thoroughfare + "." + device + ".StationStatus").getValue();//站状态地址
			if (ObjectUtil.isNotNull(stationStatusObjcet)){
			String stationStatus = stationStatusObjcet.toString();
			result = savePassingStation(thoroughfare, device,moduleCode,stationStatus);//保存过站
			if(result == 21) {
			result = saveParamCollection(device,moduleCode,stationStatus);//保存参数，发送工厂MES
			}
			}else{
			result = 23;
			log.info("读取到工位{}StationStatus数据：{},返回RecordDataDone的值为{}",device,"IS NULL！",result);
			}

			}
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".RecordDataDone").value(result).build());
			log.info("写入到工位{}的RecordDataDone数据：{}",device,result);
			}
			}

			}
			}catch (Exception e) {
			logger.error("出站保存数据异常："+e);
			log.error(e.getMessage());
			}
			}


			// /**
			// * 出站保存数据
			// */
			// public String outSaveDate(String thoroughfare,String device) {
			// String result = "";
			// try {
			// //读取SNCode
			// String PACKCode = thoroughfare + "." + device + ".PACKCode";
			// Object PACKCodeObject = miloService.readFromOpcUa(PACKCode).getValue();
			// if(null == PACKCodeObject \|\| "".equals(PACKCodeObject)){
			// result = "22";
			// }else{
			// String PACKCodeParam = PACKCodeObject.toString();
			// //1、更新工单信息
			// //updateOrderInfo();
			// //2、保存过站采集数据
			// saveStationInfo(PACKCodeParam,thoroughfare,device);
			// //3、保存参数采集数据
			// SaveParamData(PACKCodeParam,thoroughfare,device,"","");
			//
			// result = "21";
			//
			// }
			//
			// }catch (Exception e) {
			//
			// }
			// return result;
			// }

			/**
			* 保存过站采集
			*/
			public void saveStationInfo(String packCode,String thoroughfare,String device,String workOrderNo,String productCode) throws Exception {
			logger.info("进入工位{}-方法saveStationInfo",device);
			SimpleDateFormat sdf = new SimpleDateFormat("EEE MMM dd HH:mm:ss zzz yyyy", Locale.US);
			sdf.setTimeZone(TimeZone.getTimeZone("GMT+8")); // CST通常表示中国标准时间，即东八区
			String prefix = thoroughfare+"."+device+".";
			String startTime = miloService.readFromOpcUa(prefix + "StartTime").getValue().toString();
			String stopTime = miloService.readFromOpcUa(prefix + "StopTime").getValue().toString();
			String stationStatus = miloService.readFromOpcUa(prefix + "StationStatus").getValue().toString();

			DaPassingStationCollection daPassingStationCollection = new DaPassingStationCollection();
			daPassingStationCollection.setSfcCode(packCode);
			daPassingStationCollection.setWorkOrderNo(workOrderNo);
			daPassingStationCollection.setProductCode(productCode);
			daPassingStationCollection.setLocationCode(device);
			String strt = TimeUtil.stringProcessing(startTime);
			String end = TimeUtil.stringProcessing(stopTime);
			daPassingStationCollection.setInboundTime(format.parse(TimeUtil.test(strt)));//入站时间
			daPassingStationCollection.setOutboundTime(format.parse(TimeUtil.test(end)));//出站时间
			daPassingStationCollection.setOutRsSign(stationStatus);//出站是否合格
			daPassingStationCollectionService.insertDaPassingStationCollection(daPassingStationCollection);
			logger.info("结束工位{}-方法saveStationInfo",device);
			}

			public static List<DaParamCollection> SaveParamData(String packCode,String thoroughfare,String device,String workOrderNo,String productType) throws Exception {
			logger.info("进入工位{}-方法SaveParamData",device);
			List<DaCollectionParamConf> list;
			DaCollectionParamConf daCollectionParamConf = new DaCollectionParamConf();
			daCollectionParamConf.setGatherAddress(thoroughfare+ "." + device);
			list = collectionParamConfService.selectDaCollectionParamConfList(daCollectionParamConf);
			List<DaParamCollection> daParamCollectionlist = new ArrayList<>();

			List<String> nodeIdList = list.stream().map(info -> {
			String nodeid = info.getGatherAddress();
			return nodeid;
			}).collect(Collectors.toList());

			if(!nodeIdList.isEmpty()){
			List<ReadWriteEntity> readWriteEntityList = miloService.readFromOpcUa(nodeIdList);
			for(int i=0;i<nodeIdList.size();i++){
			if(readWriteEntityList.get(i).getValue() == null){
			readWriteEntityList.get(i).setValue(" ");
			}
			String paramValue = readWriteEntityList.get(i).getValue().toString();
			DaParamCollection ParamCollection = new DaParamCollection();
			ParamCollection.setParamCode(list.get(i).getCollectParameterId());
			ParamCollection.setLocationCode(device);
			if(paramValue.contains("Time")){
			ParamCollection.setParamValue(TimeUtil.test(TimeUtil.stringProcessing(paramValue)));
			}else {
			ParamCollection.setParamValue(readWriteEntityList.get(i).getValue().toString());
			}
			ParamCollection.setSfcCode(packCode);
			if(device.contains("OP360")){
			String node = nodeIdList.get(i);
			Object value = miloService.readFromOpcUa("PACK.OP360.ModuleSNCode"+node.charAt(node.length()-1)).getValue();
			if(value!=null){
			ParamCollection.setModuleCode(value.toString());
			}
			}
			ParamCollection.setParamName(list.get(i).getCollectParameterName());
			ParamCollection.setParamUpper(list.get(i).getParamUpper());
			ParamCollection.setParamLower(list.get(i).getParamLower());
			ParamCollection.setUnit(list.get(i).getCollectParameterUnit());
			ParamCollection.setType(list.get(i).getCollectParameterType());
			ParamCollection.setCollectionTime(new Date());
			ParamCollection.setWorkOrderNo(workOrderNo);
			ParamCollection.setProductCode(productType);
			daParamCollectionlist.add(ParamCollection);
			}
			}
			String RecordDataDoneAddress = thoroughfare + "." + device + ".RecordDataDone";
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(Integer.valueOf("21")).build());
			logger.info("给工位{}写了21",device);
			daParamCollectionService.saveBeachDaParamCollection(daParamCollectionlist);
			List<DaParamCollection> baseDataList = addBaseData(workOrderNo,productType,device,packCode);
			for (int i = 0; i < baseDataList.size(); i++){
			daParamCollectionlist.add(baseDataList.get(i));
			}
			logger.info("结束工位{}-方法SaveParamData",device);
			return daParamCollectionlist;
			}

			public static List<DaParamCollection> addBaseData(String workOrderNo,String productCode,String locationCode,String packCode){
			Map<String, String> map = new HashMap<>();
			map.put("GC", "南浔工厂");
			map.put("CXBH", "Pack线");
			map.put("SBBH", "设备001");
			map.put("YGBH", "员工001");
			List<DaParamCollection> confList = new ArrayList<>();
			map.forEach((key, value) -> {
			List<DaCollectionParamConf> daCollectionParamConfs = collectionParamConfService.list(new LambdaQueryWrapper<DaCollectionParamConf>()
			.eq(DaCollectionParamConf::getProcessesCode,locationCode)
			.like(DaCollectionParamConf::getCollectParameterId,key));
			DaParamCollection saveData = new DaParamCollection();
			saveData.setWorkOrderNo(workOrderNo);
			saveData.setProductCode(productCode);
			saveData.setLocationCode(locationCode);
			saveData.setSfcCode(packCode);
			saveData.setParamCode(daCollectionParamConfs.get(0).getCollectParameterId());
			saveData.setParamName(daCollectionParamConfs.get(0).getCollectParameterName());
			saveData.setCollectionTime(new Date());
			saveData.setParamValue(value);
			confList.add(saveData);
			});
			daParamCollectionService.insertBatch(confList);
			return confList;
			}

			public static void getFactoryOrder(String locationCode){
			String productionWorkOrder = RestfulService.getProductionWorkOrderRequest("", locationCode);
			JSONObject jsonObject = new JSONObject(productionWorkOrder);
			JSONObject dataObject = jsonObject.getJSONObject("data");

			String productNum = dataObject.getStr("productNum");
			String stationCode = dataObject.getStr("stationCode");
			String materialCode = dataObject.getStr("materialCode");
			String productionOrderNum = dataObject.getStr("productionOrderNum");

			OmProductionOrdeInfo omProductionOrdeInfo = new OmProductionOrdeInfo();
			omProductionOrdeInfo.setProductNum(productNum);
			omProductionOrdeInfo.setWorkOrderNo(productionOrderNum);
			omProductionOrdeInfo.setStationCode(stationCode);
			omProductionOrdeInfo.setProductCode(materialCode);
			omProductionOrdeInfoService.save(omProductionOrdeInfo);
			}

			public static void updateOrderInfo(String packCode){
			OmProductionOrdeInfo one = omProductionOrdeInfoService.getOne(new LambdaQueryWrapper<OmProductionOrdeInfo>().eq(OmProductionOrdeInfo::getProductNum, packCode));
			one.setOrderStatus("5");
			omProductionOrdeInfoService.saveOrUpdate(one);
			}

			public static void avgFunction(){

			}

			public static String TightenTheConversionOkNg(String param){
			// 去除首尾的方括号，然后按照逗号分割字符串
			String[] parts = param.substring(1, param.length() - 1).split(",");

			// 创建一个新的StringBuilder来构建替换后的字符串
			StringBuilder sb = new StringBuilder();
			sb.append('['); // 添加左方括号

			for (int i = 0; i < parts.length; i++) {
			String part = parts[i].trim(); // 去除可能的空格
			float value;
			try {
			value = Float.parseFloat(part); // 尝试将字符串转换为浮点数
			String replacement;
			if(i<2){
			replacement = part;
			}else{
			if (value == 1f) {
			replacement = "OK";
			} else{
			replacement = "NG";
			}
			}
			/* if (value == 1f) {
			replacement = "OK";
			} else if (value == 2f) {
			replacement = "NG";
			} else {
			replacement = part; // 如果不是1或2，则保持不变
			}*/
			sb.append(replacement);
			if (i < parts.length - 1) {
			sb.append(','); // 添加逗号（除了最后一个元素）
			}
			} catch (NumberFormatException e) {
			// 如果转换失败，则保持原样（或进行其他错误处理）
			sb.append(part);
			if (i < parts.length - 1) {
			sb.append(',');
			}
			}
			}
			sb.append(']'); // 添加右方括号
			return sb.toString();
			}


			/**
			* 校验是否存在NG
			* @param packCode sfcCode
			* @return boolean
			*/
			public boolean checkIsNG(String packCode,String modelCode){
			List<DaPassingStationCollection> list = daPassingStationCollectionService.list(new LambdaQueryWrapper<DaPassingStationCollection>()
			.eq(StrUtil.isNotBlank(packCode),DaPassingStationCollection::getSfcCode, packCode)
			.eq(DaPassingStationCollection::getOutRsSign, Constants.UN_PASS));
			return CollUtil.isEmpty(list);
			}

			/**
			* 保存过站采集
			*/
			public void saveStationInfo365(String thoroughfare,String device) throws Exception {
			String RecordDataDoneAddress = thoroughfare + "." + device + ".RecordDataDone";
			String prefix = thoroughfare+"."+device+".";
			List<DaPassingStationCollection> passingStationCollections = new ArrayList<>();
			String ModuleCodeA = "";
			String ModuleCodeB = "";
			String StationStatusA = "";
			String StationStatusB = "";

			Object objectModuleCodeA = miloService.readFromOpcUa(prefix + "ModuleCodeA").getValue();
			Object objectModuleCodeB = miloService.readFromOpcUa(prefix + "ModuleCodeB").getValue();
			Object objectStationStatusA = miloService.readFromOpcUa(prefix + "StationStatusA").getValue();
			Object objectStationStatusB = miloService.readFromOpcUa(prefix + "StationStatusB").getValue();

			if(ObjectUtil.isNotNull(objectModuleCodeA) && ObjectUtil.isNotNull(objectStationStatusA) && ObjectUtil.isNotNull(objectModuleCodeB) && ObjectUtil.isNotNull(objectStationStatusB)){
			ModuleCodeA = objectModuleCodeA.toString();
			ModuleCodeB = objectModuleCodeB.toString();
			StationStatusA = objectStationStatusA.toString();
			StationStatusB = objectStationStatusB.toString();

			String[] modeles = {ModuleCodeA,ModuleCodeB};
			String[] StationStatus = {StationStatusA,StationStatusB};

			String startTime = miloService.readFromOpcUa(prefix + "StartTime").getValue().toString();
			String stopTime = miloService.readFromOpcUa(prefix + "StopTime").getValue().toString();
			for (int i = 0; i < 2; i++) {
			DaPassingStationCollection daPassingStationCollection = new DaPassingStationCollection();
			String strt = TimeUtil.stringProcessing(startTime);
			String end = TimeUtil.stringProcessing(stopTime);
			daPassingStationCollection.setInboundTime(format.parse(TimeUtil.test(strt)));//入站时间
			daPassingStationCollection.setOutboundTime(format.parse(TimeUtil.test(end)));//出站时间
			daPassingStationCollection.setSfcCode(modeles[i]);
			daPassingStationCollection.setLocationCode(device);
			daPassingStationCollection.setOutRsSign(StationStatus[i]);//出站是否合格
			passingStationCollections.add(daPassingStationCollection);
			}
			daPassingStationCollectionService.saveBeachDaPassingStationCollection(passingStationCollections);
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(21).build());
			logger.info("工位{}回复21",device);

			}else {
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(RecordDataDoneAddress).value(22).build());
			}
			}

			private static void writeToOpc(String identifier, short value) {
			public synchronized void receivingWorkOrders(String thoroughfare ,String device ,String materialCode)
			{
			String paramProductNum = "";
			try {
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(identifier).value(value).build());
			// 查询最新的工单信息
			OmProductionOrdeInfo lastOrder = omProductionOrdeInfoService.getLastOrder();

			log.info("请求工厂MES工单：入参device{},materialCode：{}", device, materialCode);
			String orderJsonString = RestfulService.getProductionWorkOrderRequest(lastOrder.getProductNum(), "M1OP100",materialCode);
			JSONObject jsonObject = new JSONObject(orderJsonString);
			// 从JSONObject中获取data对象
			JSONObject dataObject = jsonObject.getJSONObject("data");
			String code = jsonObject.getStr("code");
			// 判断接单是否成功
			if(code.equals("success")) {
			log.info("请求工厂MES工单：入参pack{}出参pack：{}", paramProductNum, dataObject.getStr("productNum"));
			OmProductionOrdeInfo omProductionOrdeInfo = new OmProductionOrdeInfo();
			omProductionOrdeInfo.setWorkOrderNo(dataObject.getStr("productionOrderNum"));
			omProductionOrdeInfo.setProductNum(dataObject.getStr("productNum"));
			omProductionOrdeInfo.setStationCode(dataObject.getStr("stationCode"));
			omProductionOrdeInfo.setProductCode(dataObject.getStr("materialCode"));
			omProductionOrdeInfo.setPlanQty(Long.valueOf(dataObject.getStr("plannedQuantity")));
			omProductionOrdeInfo.setOnlineCompletionMark("0");
			omProductionOrdeInfo.setSfResult("0");
			omProductionOrdeInfo.setProductModel(dataObject.getStr("model"));
			omProductionOrdeInfo.setCreateTime(new Date());
			omProductionOrdeInfo.setCreateUser("工厂MES");
			omProductionOrdeInfoService.save(omProductionOrdeInfo);

			String productNum = dataObject.getStr("productNum");
			String orderNum = dataObject.getStr("productionOrderNum");
			//下发产品模组码
			miloService.writeToOpcUa(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".ModuleCode").value(productNum).build());
			miloService.writeToOpcUa(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".WorkOrderNumber").value(orderNum).build());

			//将产品SN发送到前台
			productNum = "productNum,"+ productNum;
			WebSocketUsers.sendMessageToUserByText(map.get(device), productNum);

			}
			} catch (Exception e) {
			throw new RuntimeException(e);
			}
			}

			/**
			* 读取电芯码
			* @param thoroughfare 通道
			* @param device 工位
			* @return list
			* @throws Exception e
			*/
			private static List<String> readCellCodeList(String thoroughfare, String device){
			List<String> cellCodeList = new ArrayList<>();
			Map map = new HashMap();
			//电芯码地址
			List<String> readList = new ArrayList<>();
			readList.add(thoroughfare + "." + device +".CellCode_1");
			readList.add(thoroughfare + "." + device +".CellCode_2");
			readList.add(thoroughfare + "." + device +".CellCode_3");
			readList.add(thoroughfare + "." + device +".CellCode_4");
			try {
			List<ReadWriteEntity> readWriteEntityList = miloService.readFromOpcUa(readList);//电芯码
			for (ReadWriteEntity readWriteEntity : readWriteEntityList) {
			if (ObjectUtil.isNotNull(readWriteEntity.getValue()) && !readWriteEntity.getValue().toString().trim().isEmpty()){
			cellCodeList.add(readWriteEntity.getValue().toString());//封装电芯码
			}else{
			cellCodeList.add("");//封装电芯码
			}
			}

			} catch (Exception e) {
			throw new RuntimeException(e);
			}
			return cellCodeList;
			}


			/**
			* 保存过站数据
			* @param thoroughfare 通道
			* @param device 工位
			* @param moduleCode 模组号
			* @param stationStatus 站状态
			* @return list
			* @throws Exception e
			*/
			private static Integer savePassingStation(String thoroughfare, String device,String moduleCode,String stationStatus){
			Integer result = 21;

			try {
			//读进站时间
			Date startTime = new Date();
			ReadWriteEntity startTimeRead = miloService.readFromOpcUa(thoroughfare + "." + device + ".StartTime");//进站时间
			if (ObjectUtil.isNotNull(startTimeRead.getValue())){
			startTime = format.parse(TimeUtil.test(TimeUtil.stringProcessing(startTimeRead.getValue().toString())));
			}else{
			result = 23;
			log.info("读取到工位{}的StartTime数据：{},返回RecordDataDone的值为{}",device,"IS NULL！",result);
			return result;
			}

			DaPassingStationCollection passingStationCollection = new DaPassingStationCollection();
			passingStationCollection.setSfcCode(moduleCode);//电芯码
			passingStationCollection.setLocationCode(device);//工位
			passingStationCollection.setInboundTime(startTime);//进站时间
			passingStationCollection.setOutboundTime(new Date());//出站时间
			passingStationCollection.setOutRsSign(stationStatus);//站状态值
			passingStationCollection.setCollectionTime(new Date());//采集时间
			daPassingStationCollectionService.save(passingStationCollection);

			} catch (Exception e) {
			throw new RuntimeException(e);
			}

			return result;
			}

			/**
			* 保存过站数据
			* @param thoroughfare 通道
			* @param device 工位
			* @param cellCodeList 电芯码集合
			* @return list
			* @throws Exception e
			*/
			private static Integer savePassingStation(String thoroughfare, String device,List<String> cellCodeList){
			Integer result = 21;

			try {
			//读进站时间
			Date startTime = new Date();
			ReadWriteEntity startTimeRead = miloService.readFromOpcUa(thoroughfare + "." + device + ".StartTime");//进站时间
			if (ObjectUtil.isNotNull(startTimeRead.getValue())){
			startTime = format.parse(TimeUtil.test(TimeUtil.stringProcessing(startTimeRead.getValue().toString())));
			}else{
			result = 23;
			log.info("读取到工位{}的StartTime数据：{},返回RecordDataDone的值为{}",device,"IS NULL！",result);
			return result;
			}

			//读工站状态
			String stationStatus = Constants.PASS;
			ReadWriteEntity stationStatusRead = miloService.readFromOpcUa(thoroughfare + "." + device + ".StationStatus");//站状态地址
			if (ObjectUtil.isNotNull(stationStatusRead.getValue())){
			String string = stationStatusRead.getValue().toString();
			if (Constants.TWO.equals(string)){
			stationStatus = Constants.UN_PASS;
			}
			}else{
			result = 23;
			log.info("读取到工位{}StationStatus数据：{},返回RecordDataDone的值为{}",device,"IS NULL！",result);
			return result;
			}

			List<DaPassingStationCollection> passingList = new ArrayList<>();
			for (String cellCode : cellCodeList) {
			DaPassingStationCollection passingStationCollection = new DaPassingStationCollection();
			if (ObjectUtil.isNotNull(cellCode) && !cellCode.isEmpty()){
			passingStationCollection.setSfcCode(cellCode);//电芯码
			passingStationCollection.setLocationCode(device);//工位
			passingStationCollection.setInboundTime(startTime);//进站时间
			passingStationCollection.setOutboundTime(new Date());//出站时间
			passingStationCollection.setOutRsSign(stationStatus);//站状态值
			passingStationCollection.setCollectionTime(new Date());//采集时间
			passingList.add(passingStationCollection);
			}
			}

			if (CollUtil.isNotEmpty(passingList)){
			daPassingStationCollectionService.insertBatch(passingList);//存储过站采集数据
			}

			} catch (Exception e) {
			throw new RuntimeException(e);
			}

			return result;
			}


			/**
			* 保存参数数据和发送工厂MES
			* @param device 工位
			* @param moduleCode 模组号
			* @param stationStatus 站状态
			* @return list
			* @throws Exception e
			*/
			private static Integer saveParamCollection(String device,String moduleCode,String stationStatus){
			Integer result = 21;//返回结果
			String sendMes = "";

			try {
			//查询参数配置表
			List<DaCollectionParamConf> list = collectionParamConfService.list(new LambdaQueryWrapper<DaCollectionParamConf>()
			.eq(DaCollectionParamConf::getProcessesCode, device)//工位
			.eq(DaCollectionParamConf::getWhetherToCollect, Constants.ONE)//是否采集
			);
			if (CollUtil.isNotEmpty(list)){

			List<String> collect = list.stream()
			.map(DaCollectionParamConf::getGatherAddress).collect(Collectors.toList());
			List<ReadWriteEntity> readWriteEntityList = miloService.readFromOpcUa(collect);

			List<DaParamCollection> collectionList = new ArrayList<>();
			List<ChildVO> mesList = new ArrayList<>();
			for (int i = 0; i < readWriteEntityList.size(); i++) {
			DaParamCollection daParamCollection = new DaParamCollection();
			daParamCollection.setSfcCode(moduleCode);//模组码
			daParamCollection.setParamCode(list.get(i).getCollectParameterId());//参数编码
			daParamCollection.setParamName(list.get(i).getCollectParameterName());//参数名称
			String paramValue = "";
			if (ObjectUtil.isNotNull(readWriteEntityList.get(i).getValue())){
			paramValue = readWriteEntityList.get(i).getValue().toString();//参数值
			if("DATE".equals(list.get(i).getCollectParameterType()) && !paramValue.isEmpty()){
			paramValue = format.parse(TimeUtil.test(TimeUtil.stringProcessing(paramValue))).toString();
			}else if("MODEL".equals(list.get(i).getCollectParameterType()) && !paramValue.isEmpty()){
			paramValue = Constants.materialMap.get(paramValue);
			}
			}
			daParamCollection.setParamValue(paramValue);//参数值
			daParamCollection.setLocationCode(device);//工位
			daParamCollection.setCollectionTime(new Date());//采集时间
			collectionList.add(daParamCollection);//封装参数采集list

			//发送给工厂mes参数封装
			ChildVO childVO = new ChildVO();
			childVO.setItemCode(list.get(i).getCollectParameterId());//参数编码
			childVO.setItemType(list.get(i).getItemType());
			childVO.setItemValue(paramValue);//参数值
			childVO.setItemText(list.get(i).getCollectParameterName());
			childVO.setCheckResult("1");
			childVO.setCheckTime(format.format(new Date()));
			mesList.add(childVO);
			}

			CompletableFuture<Void> cp1 = CompletableFuture.runAsync(() -> {
			//插入参数采集表
			daParamCollectionService.insertBatch(collectionList);

			//如果220工位，进行报工,因为上层系统只支持6位，所有报工工位修改为M1P220
			if("M1OP220".equals(device)) {
			getWorkReportResultFeedback(moduleCode, "M1P220", format.format(new Date()));
			}

			//上传到工厂mes
			ParentVO parentVO = new ParentVO();
			parentVO.setStationCode(device);//工位
			parentVO.setSiteCode("3983");

			parentVO.setRecordId(UUID.randomUUID().toString());
			if("2".equals(stationStatus)){//工站状态
			parentVO.setTotalResult("0");
			}else {
			parentVO.setTotalResult("1");
			}
			parentVO.setProductNum(moduleCode);

			//添加基础数据
			List<ChildVO> basicList = getCollectParamBasicData(device,moduleCode);
			mesList.addAll(basicList);

			parentVO.setCheckList(mesList);

			log.info("执行工厂MES方法start，工位号{} 传入数据：{}",device ,parentVO);
			HttpResponse execute = HttpRequest.post(Constants.FACTORY_EMS_UAT_GET_RUL+"deviceResultFeedback").body(JSONUtil.toJsonStr(parentVO)).execute();
			log.info("执行工厂MES方法end，工位号{} 返回数据：{}",device,execute.body());

			});
			}
			}catch (Exception e) {
			throw new RuntimeException(e);
			}
			return result;
			}

			/**
			* 保存参数数据和发送工厂MES
			* @param device 工位
			* @param cellCodeList 电芯码集合
			* @return list
			* @throws Exception e
			*/
			private static Integer saveParamCollection(String device,List<String> cellCodeList){
			Integer result = 21;//返回结果
			List<ChildVO> mesChildList1 = new ArrayList<>();//封装给工厂MES发送的childlist1
			List<ChildVO> mesChildList2 = new ArrayList<>();//封装给工厂MES发送的childlist2
			List<ChildVO> mesChildList3 = new ArrayList<>();//封装给工厂MES发送的childlist3
			List<ChildVO> mesChildList4 = new ArrayList<>();//封装给工厂MES发送的childlist4
			List<ChildVO> mesChildList0 = new ArrayList<>();//封装给工厂MES发送的childlist4
			try {
			//查询参数配置表
			List<DaCollectionParamConf> list = collectionParamConfService.list(new LambdaQueryWrapper<DaCollectionParamConf>()
			.eq(DaCollectionParamConf::getProcessesCode, device)//工位
			.eq(DaCollectionParamConf::getWhetherToCollect, Constants.ONE)//是否采集
			);//类型
			if (CollUtil.isNotEmpty(list)) {
			List<DaParamCollection> saveParamList = new ArrayList<>();//封装参数采集list
			List<DaCollectionParamConf> confColl1 = list.stream().filter(x -> Constants.INT_ONE.equals(x.getKeyNum())).collect(Collectors.toList());
			List<DaCollectionParamConf> confColl2 = list.stream().filter(x -> Constants.INT_TWO.equals(x.getKeyNum())).collect(Collectors.toList());
			List<DaCollectionParamConf> confColl3 = list.stream().filter(x -> Constants.INT_THREE.equals(x.getKeyNum())).collect(Collectors.toList());
			List<DaCollectionParamConf> confColl4 = list.stream().filter(x -> Constants.INT_FOUR.equals(x.getKeyNum())).collect(Collectors.toList());
			List<DaCollectionParamConf> confColl0 = list.stream().filter(x -> Constants.INT_ZERO.equals(x.getKeyNum())).collect(Collectors.toList());

			List<String> collect1 = confColl1.stream()
			.map(DaCollectionParamConf::getGatherAddress).collect(Collectors.toList());
			List<ReadWriteEntity> paramCollectionList1 = miloService.readFromOpcUa(collect1);//电芯1 参数值

			List<String> collect2 = confColl2.stream()
			.map(DaCollectionParamConf::getGatherAddress).collect(Collectors.toList());
			List<ReadWriteEntity> paramCollectionList2 = miloService.readFromOpcUa(collect2);//电芯2 参数值

			List<String> collect3 = confColl3.stream()
			.map(DaCollectionParamConf::getGatherAddress).collect(Collectors.toList());
			List<ReadWriteEntity> paramCollectionList3 = miloService.readFromOpcUa(collect3);//电芯3 参数值

			List<String> collect4 = confColl4.stream()
			.map(DaCollectionParamConf::getGatherAddress).collect(Collectors.toList());
			List<ReadWriteEntity> paramCollectionList4 = miloService.readFromOpcUa(collect4);//电芯4 参数值

			List<String> collect0 = confColl0.stream()
			.map(DaCollectionParamConf::getGatherAddress).collect(Collectors.toList());
			List<ReadWriteEntity> paramCollectionList0 = miloService.readFromOpcUa(collect0);//电芯参数值

			//第一个电芯的数据
			if (CollUtil.isNotEmpty(paramCollectionList1) && !cellCodeList.get(0).isEmpty()) {
			for (int i = 0; i < paramCollectionList1.size(); i++) {
			DaParamCollection daParamCollection = new DaParamCollection();
			daParamCollection.setSfcCode(cellCodeList.get(0));//电芯码
			daParamCollection.setParamCode(confColl1.get(i).getCollectParameterId());//参数编码
			daParamCollection.setParamName(confColl1.get(i).getCollectParameterName());//参数名称
			String paramValue = "";
			if (ObjectUtil.isNotNull(paramCollectionList1.get(i).getValue())) {
			paramValue = paramCollectionList1.get(i).getValue().toString();//参数值
			}
			daParamCollection.setParamValue(paramValue);//参数值
			daParamCollection.setLocationCode(device);//工位
			daParamCollection.setCollectionTime(new Date());//采集时间
			saveParamList.add(daParamCollection);//封装参数采集list

			//发送给工厂mes参数封装
			ChildVO childVO = new ChildVO();
			childVO.setItemCode(confColl1.get(i).getCollectParameterId());//参数
			childVO.setItemType(confColl1.get(i).getItemType());
			childVO.setItemValue(paramValue);//参数值
			childVO.setItemText(confColl1.get(i).getCollectParameterName());
			childVO.setCheckResult("1");
			childVO.setCheckTime(format.format(new Date()));
			mesChildList1.add(childVO);
			}

			}
			if (CollUtil.isNotEmpty(paramCollectionList2) && !cellCodeList.get(1).isEmpty()) {

			for (int i = 0; i < paramCollectionList2.size(); i++) {
			DaParamCollection daParamCollection = new DaParamCollection();
			daParamCollection.setSfcCode(cellCodeList.get(1));//电芯码
			daParamCollection.setParamCode(confColl2.get(i).getCollectParameterId());//参数编码
			daParamCollection.setParamName(confColl2.get(i).getCollectParameterName());//参数名称
			String paramValue = "";
			if (ObjectUtil.isNotNull(paramCollectionList2.get(i).getValue())) {
			paramValue = paramCollectionList2.get(i).getValue().toString();//参数值
			}
			daParamCollection.setParamValue(paramValue);//参数值
			daParamCollection.setLocationCode(device);//工位
			daParamCollection.setCollectionTime(new Date());//采集时间
			saveParamList.add(daParamCollection);//封装参数采集list

			//发送给工厂mes参数封装
			ChildVO childVO = new ChildVO();
			childVO.setItemCode(confColl2.get(i).getCollectParameterId());//参数
			childVO.setItemType(confColl2.get(i).getItemType());
			childVO.setItemValue(paramValue);//参数值
			childVO.setItemText(confColl2.get(i).getCollectParameterName());
			childVO.setCheckResult("1");
			childVO.setCheckTime(format.format(new Date()));
			mesChildList2.add(childVO);
			}
			}
			if (CollUtil.isNotEmpty(paramCollectionList3) && !cellCodeList.get(2).isEmpty()) {
			for (int i = 0; i < paramCollectionList3.size(); i++) {
			DaParamCollection daParamCollection = new DaParamCollection();
			daParamCollection.setSfcCode(cellCodeList.get(2));//电芯码
			daParamCollection.setParamCode(confColl3.get(i).getCollectParameterId());//参数编码
			daParamCollection.setParamName(confColl3.get(i).getCollectParameterName());//参数名称
			String paramValue = "";
			if (ObjectUtil.isNotNull(paramCollectionList3.get(i).getValue())) {
			paramValue = paramCollectionList3.get(i).getValue().toString();//参数值
			}
			daParamCollection.setParamValue(paramValue);//参数值
			daParamCollection.setLocationCode(device);//工位
			daParamCollection.setCollectionTime(new Date());//采集时间
			saveParamList.add(daParamCollection);//封装参数采集list

			//发送给工厂mes参数封装
			ChildVO childVO = new ChildVO();
			childVO.setItemCode(confColl3.get(i).getCollectParameterId());//参数
			childVO.setItemType(confColl3.get(i).getItemType());
			childVO.setItemValue(paramValue);//参数值
			childVO.setItemText(confColl3.get(i).getCollectParameterName());
			childVO.setCheckResult("1");
			childVO.setCheckTime(format.format(new Date()));
			mesChildList3.add(childVO);
			}
			}
			if (CollUtil.isNotEmpty(paramCollectionList4)&& !cellCodeList.get(3).isEmpty()) {
			for (int i = 0; i < paramCollectionList4.size(); i++) {
			DaParamCollection daParamCollection = new DaParamCollection();
			daParamCollection.setSfcCode(cellCodeList.get(3));//电芯码
			daParamCollection.setParamCode(confColl4.get(i).getCollectParameterId());//参数编码
			daParamCollection.setParamName(confColl4.get(i).getCollectParameterName());//参数名称
			String paramValue = "";
			if (ObjectUtil.isNotNull(paramCollectionList4.get(i).getValue())) {
			paramValue = paramCollectionList4.get(i).getValue().toString();//参数值
			}
			daParamCollection.setParamValue(paramValue);//参数值
			daParamCollection.setLocationCode(device);//工位
			daParamCollection.setCollectionTime(new Date());//采集时间
			saveParamList.add(daParamCollection);//封装参数采集list

			//发送给工厂mes参数封装
			ChildVO childVO = new ChildVO();
			childVO.setItemCode(confColl4.get(i).getCollectParameterId());//参数
			childVO.setItemType(confColl4.get(i).getItemType());
			childVO.setItemValue(paramValue);//参数值
			childVO.setItemText(confColl4.get(i).getCollectParameterName());
			childVO.setCheckResult("1");
			childVO.setCheckTime(format.format(new Date()));
			mesChildList4.add(childVO);
			}
			}

			//公共参数
			if (CollUtil.isNotEmpty(paramCollectionList0)) {
			for (int i = 0; i < cellCodeList.size(); i++) {//循环4个电芯
			if(!cellCodeList.get(i).isEmpty()){
			for (int j = 0; j < paramCollectionList0.size(); j++) {
			DaParamCollection daParamCollection = new DaParamCollection();
			daParamCollection.setSfcCode(cellCodeList.get(i));//电芯码
			daParamCollection.setParamCode(confColl0.get(j).getCollectParameterId());//参数编码
			daParamCollection.setParamName(confColl0.get(j).getCollectParameterName());//参数名称
			String paramValue = "";
			if (ObjectUtil.isNotNull(paramCollectionList0.get(j).getValue())) {
			paramValue = paramCollectionList0.get(j).getValue().toString();//参数值
			if("DATE".equals(confColl0.get(j).getCollectParameterType()) && !paramValue.isEmpty()){
			paramValue = TimeUtil.test(TimeUtil.stringProcessing(paramValue));
			}
			}
			daParamCollection.setParamValue(paramValue);//参数值
			daParamCollection.setLocationCode(device);//工位
			daParamCollection.setCollectionTime(new Date());//采集时间
			saveParamList.add(daParamCollection);

			//发送给工厂mes参数封装
			ChildVO childVO = new ChildVO();
			childVO.setItemCode(confColl0.get(j).getCollectParameterId());//参数
			childVO.setItemType(confColl0.get(j).getItemType());
			childVO.setItemValue(paramValue);//参数值
			childVO.setItemText(confColl0.get(j).getCollectParameterName());
			childVO.setCheckResult("1");
			childVO.setCheckTime(format.format(new Date()));
			mesChildList0.add(childVO);
			}
			}

			//mesList.get(i).addAll(mesChildList0);

			}

			}

			CompletableFuture<Void> cp1 = CompletableFuture.runAsync(() -> {
			//插入参数采集表
			daParamCollectionService.insertBatch(saveParamList);
			//上传到工厂mes
			ParentVO parentVO = new ParentVO();
			parentVO.setStationCode(device);//工位
			parentVO.setSiteCode("3983");

			parentVO.setRecordId(UUID.randomUUID().toString());
			parentVO.setTotalResult("1");
			for (int i = 0; i < cellCodeList.size(); i++) {//循环4个电芯
			if(!cellCodeList.get(i).isEmpty()){
			parentVO.setProductNum(cellCodeList.get(i));//电芯码
			//封装给工厂MES发送的childlist4
			List<ChildVO> mesChildList = new ArrayList<>(mesChildList0);
			switch (i) {
			case 0 :
			mesChildList.addAll(mesChildList1);
			break;
			case 1 :
			mesChildList.addAll(mesChildList2);
			break;
			case 2 :
			mesChildList.addAll(mesChildList3);
			break;
			case 3 :
			mesChildList.addAll(mesChildList4);
			break;

			}

			//添加基础数据
			List<ChildVO> basicList = getCollectParamBasicData(device,cellCodeList.get(i));
			mesChildList.addAll(basicList);

			parentVO.setCheckList(mesChildList);//参数
			//CompletableFuture<Void> cp1 = CompletableFuture.runAsync(() -> {
			log.info("执行工厂MES方法start，传入数据：{}",parentVO);
			HttpResponse execute = HttpRequest.post(Constants.FACTORY_EMS_UAT_GET_RUL+"deviceResultFeedback").body(JSONUtil.toJsonStr(parentVO)).execute();
			log.info("执行工厂MES方法end，返回数据：{}",execute.body());
			}
			}
			});
			}
			}catch (Exception e) {
			log.error(e.getMessage());
			throw new RuntimeException(e);
			}
			return result;
			}

			/**
			* 030工位返回ocv测试结果
			* @param thoroughfare
			* @param device
			* @param cellCode
			* @throws Exception
			*/
			private boolean OCVResultFeedBack(String thoroughfare, String device,String cellCode) throws Exception {
			boolean flag = true;

			List<DaTestDeviceInterfaceTemp> list = daTestDeviceInterfaceTempService.list(new LambdaQueryWrapper<DaTestDeviceInterfaceTemp>()
			.eq(DaTestDeviceInterfaceTemp::getStationCode, "M1OP020")
			.eq(DaTestDeviceInterfaceTemp::getProductNum,cellCode));
			if (CollUtil.isNotEmpty(list)){
			DaTestDeviceInterfaceTemp daTestDeviceInterfaceTemp = list.get(list.size()-1);
			if (Constants.ONE.equals(daTestDeviceInterfaceTemp.getTotalResult())){
			flag = true;
			}else {
			flag = false;
			}
			daTestDeviceInterfaceTempService.deleteDaTestDeviceInterfaceTempByProductNum(cellCode);
			}else {
			flag = false;
			log.info("读取到工位{},测试设备返回的数据查询不到，电芯码为：{}",device,cellCode);
			}
			return flag;
			}
			/**
			* 030工位返回ocv测试结果
			* @param thoroughfare
			* @param device
			* @throws Exception
			*/
			private boolean OCVResultFeedBack(String thoroughfare, String device) throws Exception {
			boolean flag = true;
			Object value1 = miloService.readFromOpcUa(thoroughfare + "." + device + ".CellCode_1").getValue();
			if (ObjectUtil.isNotNull(value1)){
			String cellCode = value1.toString();
			List<DaTestDeviceInterfaceTemp> list = daTestDeviceInterfaceTempService.list(new LambdaQueryWrapper<DaTestDeviceInterfaceTemp>()
			//.eq(DaTestDeviceInterfaceTemp::getStationCode, "M1OP020")
			.eq(DaTestDeviceInterfaceTemp::getProductNum,cellCode)
			.orderByDesc(DaTestDeviceInterfaceTemp::getCreateTime)
			);
			if (CollUtil.isNotEmpty(list)){
			DaTestDeviceInterfaceTemp daTestDeviceInterfaceTemp = list.get(0);
			if (Constants.ONE.equals(daTestDeviceInterfaceTemp.getTotalResult())){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_1").value(1).build());
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_1").value(2).build());
			}
			//daTestDeviceInterfaceTempService.deleteDaTestDeviceInterfaceTempByProductNum(cellCode);
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_1").value(5).build());
			log.info("读取到工位{},OP020工位没有给测试结果",device);
			}
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_1").value(5).build());
			log.info("读取到工位{},PLC没有给电芯码",device);
			}
			Object value2 = miloService.readFromOpcUa(thoroughfare + "." + device + ".CellCode_2").getValue();
			if (ObjectUtil.isNotNull(value2)){
			String cellCode = value2.toString();
			List<DaTestDeviceInterfaceTemp> list = daTestDeviceInterfaceTempService.list(new LambdaQueryWrapper<DaTestDeviceInterfaceTemp>()
			//.eq(DaTestDeviceInterfaceTemp::getStationCode, "M1OP020")
			.eq(DaTestDeviceInterfaceTemp::getProductNum,cellCode));
			if (CollUtil.isNotEmpty(list)){
			DaTestDeviceInterfaceTemp daTestDeviceInterfaceTemp = list.get(list.size()-1);
			if (Constants.ONE.equals(daTestDeviceInterfaceTemp.getTotalResult())){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_2").value(1).build());
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_2").value(2).build());
			}
			//daTestDeviceInterfaceTempService.deleteDaTestDeviceInterfaceTempByProductNum(cellCode);
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_2").value(5).build());
			log.info("读取到工位{},OP020工位没有给测试结果",device);
			}
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_2").value(5).build());
			log.info("读取到工位{},PLC没有给电芯码",device);
			}

			Object value3 = miloService.readFromOpcUa(thoroughfare + "." + device + ".CellCode_3").getValue();
			if (ObjectUtil.isNotNull(value3)){
			String cellCode = value3.toString();
			List<DaTestDeviceInterfaceTemp> list = daTestDeviceInterfaceTempService.list(new LambdaQueryWrapper<DaTestDeviceInterfaceTemp>()
			//.eq(DaTestDeviceInterfaceTemp::getStationCode, "M1OP020")
			.eq(DaTestDeviceInterfaceTemp::getProductNum,cellCode));
			if (CollUtil.isNotEmpty(list)){
			DaTestDeviceInterfaceTemp daTestDeviceInterfaceTemp = list.get(list.size()-1);
			if (Constants.ONE.equals(daTestDeviceInterfaceTemp.getTotalResult())){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_3").value(1).build());
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_3").value(2).build());
			}
			//daTestDeviceInterfaceTempService.deleteDaTestDeviceInterfaceTempByProductNum(cellCode);
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_3").value(5).build());
			log.info("读取到工位{},OP020工位没有给测试结果",device);
			}
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_3").value(5).build());
			log.info("读取到工位{},PLC没有给电芯码",device);
			}

			Object value4 = miloService.readFromOpcUa(thoroughfare + "." + device + ".CellCode_4").getValue();
			if (ObjectUtil.isNotNull(value4)){
			String cellCode = value4.toString();
			List<DaTestDeviceInterfaceTemp> list = daTestDeviceInterfaceTempService.list(new LambdaQueryWrapper<DaTestDeviceInterfaceTemp>()
			//.eq(DaTestDeviceInterfaceTemp::getStationCode, "M1OP020")
			.eq(DaTestDeviceInterfaceTemp::getProductNum,cellCode));
			if (CollUtil.isNotEmpty(list)){
			DaTestDeviceInterfaceTemp daTestDeviceInterfaceTemp = list.get(list.size()-1);
			if (Constants.ONE.equals(daTestDeviceInterfaceTemp.getTotalResult())){
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_4").value(1).build());
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_4").value(2).build());
			}
			//daTestDeviceInterfaceTempService.deleteDaTestDeviceInterfaceTempByProductNum(cellCode);
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_4").value(5).build());
			log.info("读取到工位{},OP020工位没有给测试结果",device);
			}
			}else {
			flag = false;
			miloService.writeToOpcShort(ReadWriteEntity.builder().identifier(thoroughfare + "." + device + ".CellStatus_4").value(5).build());
			log.info("读取到工位{},PLC没有给电芯码",device);
			}

			return flag;
			}

			/**
			* AMES报工结果回传
			* @param productNum
			* @param stationCode
			* @param confirmTime
			* @return
			*/
			//{"code":"success","data":{"productNum":"LCV123456P0600036","stationCode":"1HZ01","resultCode":"S","resultText":"报工成功"},"message":"API调用成功"}
			public static String getWorkReportResultFeedback(String productNum,String stationCode,String confirmTime)
			{
			String result = "";
			try {
			String url = Constants.FACTORY_EMS_UAT_GET_RUL + "workReportResultFeedback?siteCode="+Constants.FACTORY_EMS_SITE_CODE+"&stationCode="+stationCode+"&productNum="+productNum+"&confirmTime="+confirmTime;
			HttpResponse response = HttpRequest.get(url).execute();
			HttpRequest httpRequest = HttpRequest.get(url);
			result = response.body();
			}catch (Exception e){
			throw new RuntimeException(e);
			}finally {
			return result;
			}
			}


			/**
			* 获取采集参数基础数据
			* @param stationCode
			* @param sfcCode
			* @return list
			*/
			public static List<ChildVO> getCollectParamBasicData(String stationCode,String sfcCode) {
			List<ChildVO> basicList = new ArrayList<>();
			List<DaParamCollection> collectionList = new ArrayList<>();
			try {
			//查询参数配置表
			List<DaCollectionParamConf> list = collectionParamConfService.list(new LambdaQueryWrapper<DaCollectionParamConf>()
			.eq(DaCollectionParamConf::getProcessesCode, stationCode)//工位
			.eq(DaCollectionParamConf::getCollectParameterType, "BASIC")//采集参数类型
			);
			if (CollUtil.isNotEmpty(list)){
			for(DaCollectionParamConf conf:list){
			ChildVO childVO = new ChildVO();
			childVO.setItemCode(conf.getCollectParameterId());//参数
			childVO.setItemType(conf.getItemType());
			childVO.setItemValue(conf.getParamCentral());//参数值
			childVO.setItemText(conf.getCollectParameterName());
			childVO.setCheckResult("1");
			childVO.setCheckTime(format.format(new Date()));
			basicList.add(childVO);

			DaParamCollection daParamCollection = new DaParamCollection();
			daParamCollection.setSfcCode(sfcCode);//模组码
			daParamCollection.setParamCode(conf.getCollectParameterId());//参数编码
			daParamCollection.setParamName(conf.getCollectParameterName());//参数名称

			daParamCollection.setParamValue(conf.getParamCentral());//参数值
			daParamCollection.setLocationCode(stationCode);//工位
			daParamCollection.setCollectionTime(new Date());//采集时间
			collectionList.add(daParamCollection);//封装参数采集list
			}
			daParamCollectionService.insertBatch(collectionList);
			}
			return basicList;
			}catch (Exception e) {
			throw new RuntimeException(e);
			}
			}



			}