package com.northglass.service.arrangemachine;
|
|
import java.util.Date;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Component;
|
import org.springframework.transaction.annotation.Transactional;
|
|
import com.northglass.constants.StateConstants.ArrangeMachineState;
|
import com.northglass.constants.StateConstants.ConnectState;
|
import com.northglass.entity.ArrangeMachine;
|
import com.northglass.entity.ArrangeMachineRank;
|
import com.northglass.entity.ArrangeMachineTask;
|
import com.northglass.entity.ShelfStatu;
|
import com.northglass.entity.TestOut;
|
import com.northglass.entity.TougheningGlass;
|
import com.northglass.listener.ArrangeMachineClientListener;
|
import com.northglass.repository.ArrangeMachineDao;
|
import com.northglass.repository.ArrangeMachineRankDao;
|
import com.northglass.repository.ArrangeMachineTaskDao;
|
import com.northglass.repository.ShelfStatuDao;
|
import com.northglass.repository.TestOutDao;
|
import com.northglass.service.message.ArrangeMachineMessageProcessor;
|
|
|
@Component
|
@Transactional
|
public class ArrangeMachineService {
|
|
private static final Logger LOGGER = LoggerFactory.getLogger(ArrangeMachineService.class);
|
|
@Autowired
|
private ArrangeMachineRankDao arrangeMachineRankDao;
|
|
@Autowired
|
private ArrangeMachineTaskDao arrangeMachineTaskDao;
|
|
@Autowired
|
private ArrangeMachineDao arrangeMachineDao;
|
|
@Autowired
|
private TestOutDao testOutDao;
|
|
@Autowired
|
private ArrangeMachineMessageProcessor processor;
|
|
@Autowired
|
private ShelfStatuDao shelfStatuDao;
|
|
public ArrangeMachineRank getFreeRank() {
|
LOGGER.debug("> Start getFreeRank");
|
|
List<ArrangeMachineRank> rankList = arrangeMachineRankDao.findFreeRanks();
|
if (rankList.size() == 0) {
|
LOGGER.error("没有空闲的理片货架！");
|
return null;
|
}
|
|
LOGGER.debug("> End getFreeRank");
|
return rankList.get(0);
|
}
|
|
public List<ArrangeMachineRank> getFreeRanks() {
|
LOGGER.debug("> Start getFreeRank");
|
|
List<ArrangeMachineRank> rankList = arrangeMachineRankDao.findFreeRanks();
|
if (rankList.size() == 0) {
|
LOGGER.error("没有空闲的理片货架！");
|
return null;
|
}
|
|
LOGGER.debug("> End getFreeRank");
|
return rankList;
|
}
|
|
public void resetState() {
|
List<ArrangeMachine> machineList = arrangeMachineDao.findAll();
|
|
for (ArrangeMachine machine : machineList) {
|
machine.setConnectState(ConnectState.NO_CONNECT);
|
machine.setState(ArrangeMachineState.STOPPED);
|
}
|
|
arrangeMachineDao.save(machineList);
|
}
|
|
public ArrangeMachineTask saveArrangeMachineTask(ArrangeMachineTask task) {
|
return arrangeMachineTaskDao.save(task);
|
}
|
|
public ArrangeMachineRank saveArrangeMachineRank(ArrangeMachineRank rank) {
|
return arrangeMachineRankDao.save(rank);
|
}
|
|
public ArrangeMachine saveArrangeMachine(ArrangeMachine arrangeMachine) {
|
return arrangeMachineDao.save(arrangeMachine);
|
}
|
|
public List<ArrangeMachineTask> getWaitingTasks() {
|
List<ArrangeMachineTask> taskList = arrangeMachineTaskDao.findWaitingTasks();
|
return taskList;
|
}
|
|
public List<ArrangeMachineTask> getWaitingInTasks() {
|
return arrangeMachineTaskDao.findWaitingInTasks();
|
}
|
|
public List<ArrangeMachineTask> getWaitingOutTasks() {
|
return arrangeMachineTaskDao.findWaitingOutTasks();
|
|
}
|
|
public List<ArrangeMachineTask> findWaitingTasks() {
|
List<ArrangeMachineTask> taskList = arrangeMachineTaskDao.findWaitingTasks();
|
return taskList;
|
}
|
|
|
public List<ArrangeMachineTask> findInWorkTask() {
|
return arrangeMachineTaskDao.findInWorkTask();
|
}
|
|
|
public ArrangeMachineTask getToStartTask() {
|
return arrangeMachineTaskDao.findToStartTask();
|
}
|
|
public ArrangeMachineTask getToCloseTask() {
|
return arrangeMachineTaskDao.findToCloseTask();
|
}
|
|
|
|
|
/*
|
*
|
* 1：整理模式算发调度 1.找到我们需要出片的下一个要出片的玻璃数据 2.找到理片里边的rank数据
|
* 3.循环判断理片数据中有没有我们需要出片的一个型号 有的话直接跳出来，创建出片任务
|
*
|
* 2：(弃用) 1.找到我们需要出片的下一个要出片的玻璃数据 2.根据玻璃数据找到rank 如果rank有数据，我们可以出片任务，没有就不用处理 *
|
*/
|
|
public void stepclearRank() {
|
// List<ArrangeMachineRank> arrangeMachineRanks = arrangeMachineRankDao.findInWorkRanks();
|
// List<Glass> glasses = glassDao.findByglass(0);
|
// if (glasses.size() > 0) {
|
// Glass glass = glasses.get(0);
|
// ArrangeMachineRank arrangeMachineRank = null;
|
// TougheningGlass tougheningGlass = null;
|
// for (ArrangeMachineRank rank : arrangeMachineRanks) {
|
// if (rank.getTougheningGlass().getGlass().getId() == glass.getId()) {
|
// glass.setGlassId(1);
|
// glassDao.save(glass);
|
// arrangeMachineRank = rank;
|
// tougheningGlass = rank.getTougheningGlass();
|
// break;
|
// }
|
//
|
// }
|
// ArrangeMachineRank arrangeMachineRank =
|
// arrangeMachineRankDao.findGlassRanks(glass.getId());
|
// if (arrangeMachineRank !=null) {
|
// glass.setGlassId(1);
|
// glassDao.save(glass);
|
// TougheningGlass tougheningGlass =
|
// arrangeMachineRank.getTougheningGlass();
|
// 创建理片机任务
|
// if (tougheningGlass != null) {
|
// ArrangeMachineTask exitRankTask = new ArrangeMachineTask(ArrangeMachineTaskState.WAITING,
|
// ArrangeMachineTaskType.EXIT_RANK, "01", new Date(), tougheningGlass, null, arrangeMachineRank);
|
// saveArrangeMachineTask(exitRankTask);
|
// }
|
|
// }
|
}
|
|
public void getendtime(String name) {
|
List<TestOut> testOuts = testOutDao.findByName(name);
|
if (testOuts.size() > 0) {
|
TestOut testOut = testOuts.get(testOuts.size() - 1);
|
if (testOut.getEnd_time() != null && !testOut.getEnd_time().equals("")) {
|
TestOut test = new TestOut(name);
|
test.setStart_time(new Date());
|
testOutDao.save(test);
|
} else {
|
testOut.setEnd_time(new Date());
|
testOutDao.save(testOut);
|
}
|
} else {
|
TestOut testOut = new TestOut(name + "start");
|
testOut.setStart_time(new Date());
|
testOutDao.save(testOut);
|
}
|
}
|
|
public void getright(String name) {
|
TestOut testOut = new TestOut(name);
|
testOut.setStart_time(new Date());
|
testOutDao.save(testOut);
|
}
|
|
// // 变换模式
|
// public void modifystatu(String statu) {
|
// ArrangeMachineStatu arrangeMachineStatu = arrangeMachineStatuDao.findOne((long) 1);
|
// arrangeMachineStatu.setState(statu);
|
// arrangeMachineStatuDao.save(arrangeMachineStatu);
|
// }
|
|
// public void piecestatu() {
|
// ArrangePiecesStatu arrangePiecesStatu = arrangePiecesStatuDao.findOne((long) 1);
|
// if (arrangePiecesStatu.getState().equals(ArrangePieceStatu.WAITING)) {
|
// arrangePiecesStatu.setState(ArrangePieceStatu.WORKING);
|
// } else {
|
// arrangePiecesStatu.setState(ArrangePieceStatu.WAITING);
|
// }
|
// arrangePiecesStatuDao.save(arrangePiecesStatu);
|
// }
|
|
public int getpieces() {
|
List<ArrangeMachineRank> rank = arrangeMachineRankDao.findInWorkRanks();
|
return rank.size();
|
}
|
|
public Object getEditArrangeMachineRankHtml() {
|
return null;
|
}
|
|
public void loadData() {
|
|
}
|
|
public void addData() {
|
|
}
|
|
public void clearData() {
|
|
}
|
|
public void connect() {
|
LOGGER.debug("> Start connect");
|
|
List<ArrangeMachine> machineList = arrangeMachineDao.findAll();
|
|
// 若监听线程为空，则新建监听线程
|
for (ArrangeMachine machine : machineList) {
|
if (machine.getServerConnection().getThread() == null) {
|
LOGGER.debug("创建新的理片【" + machine.getNumber() + "】监听线程！");
|
Thread thread = new Thread(new ArrangeMachineClientListener(machine,this));
|
thread.start();
|
|
setConnectState(machine, ConnectState.CONNECTING);
|
machine.getServerConnection().setThread(thread);
|
}
|
}
|
|
LOGGER.debug("> End connect");
|
}
|
|
public void setConnectState(ArrangeMachine machineClient, String connectState) {
|
machineClient.setConnectState(connectState);
|
machineClient.setModifyTime(new Date());
|
arrangeMachineDao.save(machineClient);
|
}
|
|
public String processMessage(String message, ArrangeMachine machineClient) {
|
return processor.generateReturnMessage(message, machineClient);
|
}
|
|
public ArrangeMachineRank getrank(TougheningGlass tougheningGlass) {
|
List<ArrangeMachineRank> arrangeMachineRanks = arrangeMachineRankDao.findRanksbyglassid(tougheningGlass.getGlass().getId());
|
if (arrangeMachineRanks.size()>0) {
|
for (int i = 0; i < arrangeMachineRanks.size(); i++) {
|
ArrangeMachineRank rank = arrangeMachineRanks.get(i);
|
TougheningGlass tou = rank.getTougheningGlass();
|
if (tougheningGlass.getActualLength() == tou.getActualLength()&&
|
tougheningGlass.getActualWidth()== tou.getActualWidth() &&
|
tougheningGlass.getActualLength()*(rank.getPieces()+1)+rank.getPieces()*250<4000&&
|
rank.getPieces()<2
|
) {
|
return arrangeMachineRanks.get(i);
|
}
|
if (i == arrangeMachineRanks.size()-1) {
|
List<ArrangeMachineRank> rankList = arrangeMachineRankDao.findFreeRanks();
|
if (rankList.size() == 0) {
|
LOGGER.error("没有空闲的理片货架！");
|
return null;
|
}else {
|
return rankList.get(0);
|
}
|
}
|
}
|
|
}else {//直接找新的空笼
|
List<ArrangeMachineRank> rankList = arrangeMachineRankDao.findFreeRanks();
|
if (rankList.size() == 0) {
|
LOGGER.error("没有空闲的理片货架！");
|
return null;
|
}else {
|
return rankList.get(0);
|
}
|
}
|
return null;
|
}
|
|
public Map<String, Object> showarrangeinfo(String string) {
|
Map<String, Object> param=new HashMap<String, Object>();
|
ShelfStatu statu = shelfStatuDao.findByMachine(string);
|
String message = statu.getMessage();
|
param.put("taskAsk", message.substring(0, 4));// 请求信号
|
param.put("taskOneAsk", message.substring(8, 12));// 1号请求ID
|
param.put("taskTwoAsk", message.substring(12, 16));// 2请求信号
|
param.put("taskThreeAsk", message.substring(16, 20));//3请求信号
|
param.put("taskFinish", message.substring(20, 24));// 任务汇报字1
|
param.put("taskTwoFinish", message.substring(24, 28));// 任务汇报字2
|
param.put("taskThreeFinish", message.substring(28, 32));// 任务汇报字3
|
param.put("taskFinishId", message.substring(32, 36));// 请求信号
|
param.put("taskMes", message.substring(40, 44));// 请求信号
|
param.put("taskSure", message.substring(80, 84));// 请求信号
|
param.put("taskWarning", message.substring(120, 124));// 任务报警字
|
param.put("finishStep", message.substring(160, 164));// 完成步骤
|
return param;
|
}
|
|
|
}
|
