~admin/HangZhouMes.git

			@@ -1,68 +1,280 @@
			package com.mes.job;

			import cn.hutool.json.JSONObject;
			import cn.smallbun.screw.core.util.CollectionUtils;
			import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
			import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
			import com.mes.common.config.Const;
			import com.mes.common.utils.RedisUtil;
			import com.mes.downglassinfo.entity.DownGlassInfo;
			import com.mes.downglassinfo.entity.DownGlassTask;
			import com.mes.downglassinfo.entity.request.DownGlassInfoRequest;
			import com.mes.downglassinfo.service.DownGlassInfoService;
			import com.mes.downglassinfo.service.DownGlassTaskService;
			import com.mes.downstorage.service.DownStorageCageService;
			import com.mes.downworkstation.entity.DownWorkstation;
			import com.mes.downworkstation.service.DownWorkstationService;
			import com.mes.glassinfo.entity.GlassInfo;
			import com.mes.glassinfo.service.GlassInfoService;
			import com.mes.tools.DateUtil;
			import com.mes.tools.WebSocketServer;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.scheduling.annotation.Scheduled;
			import lombok.extern.slf4j.Slf4j;
			import org.apache.commons.lang.StringUtils;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.beans.factory.annotation.Value;
			import org.springframework.scheduling.TaskScheduler;
			import org.springframework.scheduling.annotation.Async;
			import org.springframework.scheduling.annotation.Scheduled;
			import org.springframework.stereotype.Component;

			import java.io.BufferedReader;
			import java.io.InputStreamReader;
			import java.net.InetSocketAddress;
			import java.net.Socket;
			import java.util.ArrayList;
			import java.util.List;
			import java.util.Map;
			import java.util.concurrent.*;
			import java.util.stream.Collectors;

			@Slf4j
			@Component
			public class Downpush {


			@Autowired
			private DownWorkstationService downWorkstationService;
			@Scheduled(fixedDelay = 1000)
			public void Downpush() {
			@Autowired
			private DownStorageCageService downStorageCageService;
			@Autowired
			private DownGlassInfoService downGlassInfoService;
			@Autowired
			private DownGlassTaskService downGlassTaskService;
			@Autowired
			private GlassInfoService glassInfoService;
			private final ExecutorService scanCodeThreadPool = new ThreadPoolExecutor(
			10, // core pool size
			20, // maximum pool size
			60L, TimeUnit.SECONDS,
			new LinkedBlockingQueue<>()
			);
			private final ExecutorService isRunThreadPool = Executors.newFixedThreadPool(5);

			@Value("${mes.scan.ip}")
			private String scanIp;

			@Value("${mes.scan.port}")
			private Integer scanPort;

			@Autowired
			private RedisUtil redisUtil;

			@Scheduled(fixedDelay = 2000)
			public void sendDownWorkstations() {
			log.info("发送工位玻璃信息");
			JSONObject jsonObject = new JSONObject();
			JSONObject jsonObject2 = new JSONObject();
			JSONObject jsonObject3 = new JSONObject();

			List<DownWorkstation> data = downWorkstationService.getoneDownWorkstations(1,6);
			List<Map<String, Object>> glassinfodata = downWorkstationService.getTotalGlassDimensionsByWorkstation(1,3);
			List<Map<String, Object>> glassinfodata2 = downWorkstationService.getTotalGlassDimensionsByWorkstation(4,6);
			jsonObject.append("params",data);
			jsonObject2.append("glassinfo",glassinfodata);
			jsonObject3.append("glassinfo2",glassinfodata2);
			List<DownWorkstation> data = downWorkstationService.list();
			jsonObject.append("params", data);
			log.info(jsonObject.toString());
			ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("unloadglass");
			ArrayList<WebSocketServer> sendwServer2 = WebSocketServer.sessionMap.get("unloadglass2");
			ArrayList<WebSocketServer> sendwServer3 = WebSocketServer.sessionMap.get("unloadglass3");
			// log.info(sendwServer.toString());
			if (sendwServer != null) {
			for (WebSocketServer webserver : sendwServer) {

			if (webserver != null&&webserver.session.isOpen()) {
			if (webserver != null && webserver.session.isOpen()) {
			log.info("已发送");
			webserver.sendMessage(jsonObject.toString());
			}
			}
			}
			}

			@Scheduled(fixedDelay = 1000)
			public void sendGlassInfoData() {
			log.info("发送工位显示图信息1");
			JSONObject jsonObject2 = new JSONObject();
			List<Map<String, Object>> glassinfodata = downWorkstationService.getTotalGlassDimensionsByWorkstation(1, 3);
			jsonObject2.append("glassinfo", glassinfodata);
			log.info(jsonObject2.toString());
			ArrayList<WebSocketServer> sendwServer2 = WebSocketServer.sessionMap.get("unloadglass2");
			if (sendwServer2 != null) {
			for (WebSocketServer webserver : sendwServer2) {

			if (webserver != null&&webserver.session.isOpen()) {
			if (webserver != null && webserver.session.isOpen()) {
			webserver.sendMessage(jsonObject2.toString());
			}
			}
			}
			}

			@Scheduled(fixedDelay = 1000)
			public void sendGlassInfoData2() {
			log.info("发送工位显示图信息2");
			JSONObject jsonObject3 = new JSONObject();
			List<Map<String, Object>> glassinfodata2 = downWorkstationService.getTotalGlassDimensionsByWorkstation(4, 6);
			jsonObject3.append("glassinfo2", glassinfodata2);
			log.info(jsonObject3.toString());
			ArrayList<WebSocketServer> sendwServer3 = WebSocketServer.sessionMap.get("unloadglass3");
			if (sendwServer3 != null) {
			for (WebSocketServer webserver : sendwServer3) {

			if (webserver != null&&webserver.session.isOpen()) {
			if (webserver != null && webserver.session.isOpen()) {
			webserver.sendMessage(jsonObject3.toString());
			}
			}
			}
			}

			@Scheduled(fixedDelay = 2000)
			public void sendDownStorageCages() {
			log.info("发送缓存玻璃信息");
			JSONObject jsonObject4 = new JSONObject();
			List<Map<String, Object>> list = downStorageCageService.selectDownStorageCages();
			jsonObject4.append("params2", list);
			log.info(jsonObject4.toString());
			ArrayList<WebSocketServer> sendwServer4 = WebSocketServer.sessionMap.get("downcache");
			if (sendwServer4 != null) {
			for (WebSocketServer webserver : sendwServer4) {
			if (webserver != null && webserver.session.isOpen()) {
			webserver.sendMessage(jsonObject4.toString());
			}
			}
			}
			}

			@Scheduled(fixedDelay = 2000)
			public void sendDownGlassInfo() {
			DownGlassInfoRequest request = redisUtil.getCacheObject("downGlassRequest");
			if (null == request) {
			request = new DownGlassInfoRequest();
			}
			if (request.getBeginDate() == null) {
			request.setBeginDate(DateUtil.getBeginDate());
			request.setEndDate(DateUtil.getEndDate());
			}
			log.info("发送当前正在执行工程已落架的玻璃信息");
			LambdaQueryWrapper<DownGlassInfo> wrapper = new LambdaQueryWrapper<DownGlassInfo>()
			.between(null != request.getBeginDate(), DownGlassInfo::getGmtCreate, request.getBeginDate(), request.getEndDate())
			.eq(StringUtils.isNotBlank(request.getEngineerId()), DownGlassInfo::getEngineerId, request.getEngineerId());
			if (null == request.getWorkStationId() \|\| 0 == request.getWorkStationId()) {
			wrapper.in(DownGlassInfo::getWorkStationId, Const.WORK_STATION_ALL);
			} else {
			wrapper.eq(DownGlassInfo::getWorkStationId, request.getWorkStationId());
			}
			List<DownGlassInfo> downGlassInfos = downGlassInfoService.list(wrapper);
			// Map<Integer, List<DownGlassInfo>> listMap = downGlassInfos.stream().collect(Collectors.groupingBy(DownGlassInfo::getWorkStationId));
			List<Object> engineerIdListTemp = downGlassInfoService.listObjs(new QueryWrapper<DownGlassInfo>().select("distinct engineer_id"));
			List<String> engineerIdList = engineerIdListTemp.stream().map(String::valueOf).collect(Collectors.toList());
			JSONObject jsonObject4 = new JSONObject();
			jsonObject4.append("downGlassInfos", downGlassInfos);
			jsonObject4.append("engineerIdList", engineerIdList);

			//钢化开关
			boolean autoPrint = false;
			if (redisUtil.getCacheObject("autoPrint") == null) {
			redisUtil.setCacheObject("autoPrint", false);
			} else {
			autoPrint = redisUtil.getCacheObject("autoPrint");
			}
			jsonObject4.append("autoPrint", autoPrint);
			//人工下片位置最后一片
			DownGlassTask takeGlass = downGlassTaskService.getOne(
			new QueryWrapper<DownGlassTask>()
			.select("Top 1 *")
			.eq("end_cell", Const.G13_WORK_STATION)
			.lt("task_status", Const.UNLOAD_GLASS_DOWN)
			.orderByDesc("id")
			);
			jsonObject4.append("takeGlass", takeGlass);


			ArrayList<WebSocketServer> sendwServer4 = WebSocketServer.sessionMap.get("unloadglass");
			if (sendwServer4 != null) {
			for (WebSocketServer webserver : sendwServer4) {
			if (webserver != null && webserver.session.isOpen()) {
			webserver.sendMessage(jsonObject4.toString());
			}
			}
			}
			}

			@Scheduled(fixedDelay = 1000)
			public void isRun() {
			isRunThreadPool.execute(() -> {
			JSONObject jsonObject = new JSONObject();
			//正在进行的任务
			List<DownWorkstation> downWorkstation = downWorkstationService.getoneDownWorkstations(1, 6);
			jsonObject.append("downWorkstation", downWorkstation);
			List<DownGlassTask> downGlassTask = downGlassTaskService.selectOutTaskCache();
			jsonObject.append("downGlassTask", downGlassTask);
			ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("unLoadGlassIsRun");
			if (sendwServer != null) {
			for (WebSocketServer webserver : sendwServer) {
			if (webserver != null) {
			webserver.sendMessage(jsonObject.toString());
			} else {
			log.info("unLoadGlassIsRun is closed");
			}
			}
			}
			});

			}

			@Async
			@Scheduled(fixedDelay = Long.MAX_VALUE)
			public void scanCodeTask() {
			JSONObject jsonObject = new JSONObject();
			log.info("扫描任务已启动");
			while (true) {
			try (Socket socket = new Socket(scanIp, scanPort);
			BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
			// 接收服务器响应
			// socket.setSoTimeout(1000);
			log.info("等待扫码中......");
			String glassId = in.readLine();
			log.info("扫描到的玻璃id：{}", glassId);
			List<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("unloadglass");
			if (CollectionUtils.isNotEmpty(sendwServer)) {
			//按照玻璃id获取玻璃信息返回给前端界面，具体需要哪些数据待确认
			GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
			.eq(GlassInfo::getGlassId, glassId).last("limit 1"));
			if (null == glassInfo) {
			log.info("按照玻璃id：{}，无法找到玻璃信息", glassId);
			} else {
			jsonObject.append("scanGlass",glassInfo);
			sendwServer.get(0).sendMessage(jsonObject.toString());
			}
			}
			} catch (Exception exception) {
			log.info("读取异常，原因为{}", exception.getMessage());
			}
			}
			}

			@Scheduled(fixedDelay = Long.MAX_VALUE)
			public void scanCodeTaskCopy()
			{
			log.info("扫描任务已启动");
			try {
			BarcodeReadThread brt=new BarcodeReadThread(scanIp,scanPort,this);
			brt.start();

			}catch (Exception exception) {
			log.info("扫描任务启动异常，原因为{}", exception.getMessage());
			}

			}
			//socket读取到消息后会调用这个函数
			public void barcodeCheckin(String response)
			{
			log.info("扫描到的玻璃id：{}", response);
			List<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("scanCode");
			if (CollectionUtils.isNotEmpty(sendwServer)) {
			//按照玻璃id获取玻璃信息返回给前端界面，具体需要哪些数据待确认
			GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
			.eq(GlassInfo::getGlassId, response).last("limit 1"));
			if (null == glassInfo) {
			log.info("按照玻璃id：{}，无法找到玻璃信息", response);
			} else {
			sendwServer.get(0).sendMessage(glassInfo.toString());
			}
			}
			}
			}