iamberry-common-parent/watero-rst-web/src/main/java/com/iamberry/rst/controllers/pts/MachineController.java

package com.iamberry.rst.controllers.pts;

import com.iamberry.rst.controllers.sys.SysController;
import com.iamberry.rst.core.pts.*;
import com.iamberry.rst.core.tools.QRCJson;
import com.iamberry.rst.core.tools.WeixinUtil;
import com.iamberry.rst.faces.pts.*;
import com.iamberry.wechat.tools.NameUtils;
import com.iamberry.wechat.tools.RespJsonBean;
import com.iamberry.wechat.tools.ResponseJson;
import com.iamberry.wechat.tools.ResultInfo;
import net.sf.json.JSONArray;
import net.sf.json.JSONObject;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import javax.servlet.http.HttpServletRequest;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * Created by LJK on 2017/8/29.
 */
@Controller
@RequestMapping("/mcahine")
public class MachineController {
    private static Logger logger = LoggerFactory.getLogger(MachineController.class);

    @Autowired
    private ProduceService produceService;

    @Autowired
    private MachineService machineService;

    @Autowired
    private DeviceService deviceService;

    @Autowired
    private PtsEmployeeService ptsEmployeeService;

    @Autowired
    private MachineLogsService machineLogsService;

    @Autowired
    private PtsBatchService ptsBatchService;



    @ResponseBody
    @RequestMapping("/uploadProcessOptions")
    public ResponseJson uploadProcessOptions(HttpServletRequest request) {
        ResponseJson rj = new ResponseJson();
        String nodeList = request.getParameter("nodeList"); //获取员工id
        logger.info("--------------生成机器------------");
        logger.info("获取数据：nodeList" + nodeList);
        if (nodeList == null || nodeList.equals("")) {
            rj.setResultCode(500);
            rj.setResultMsg("200");
            rj.setResultMsg("ERROR");
            return rj;
        }
        JSONObject query = JSONObject.fromObject(nodeList);
        Integer employeeId = query.getInt("employeeId");//员工id
        String produceNo = query.getString("produceId");//产品编号
        String nfcId = query.getString("nfcId");//NFCID(卡片id)
        JSONArray nodes = query.getJSONArray("nodes");//选项集合（包含一个或多个工序选项，详情见示例）

        //根据卡片id与生产时间判断数据库是否存在相同的数据
        JSONObject machineJsonObject = nodes.getJSONObject(0);
        String ProcessTime = machineJsonObject.getString("logsProcessTime"); //工序执行时间 （时间戳）
        Date ProcessDate = timeConversions(ProcessTime);
        PtsMachine machine = new PtsMachine();
        machine.setMachineNfcId(nfcId);
        machine.setMachineCreateTime(ProcessDate);
        Integer ishave = machineService.getMachineIsHave(machine);
        if (ishave > 0) {
            rj.setResultCode(500);
            rj.setResultMsg("500");
            rj.setResultMsg("此卡片内容已生成二维码");
            return rj;
        }
        Produce produce = produceService.getProduce(produceNo);//根据产品编号获取产品信息

        /*根据员工id，获取拉线，再将拉线存入机器表 */
        PtsEmployee employee = new PtsEmployee();
        employee.setEmployeeId(employeeId);
        employee = ptsEmployeeService.getPtsEmployeeWebApp(employee);
        String employeeLine = employee.getEmployeeLine();
        /*获取当前产品使用的批次 */
        PtsBatch ptsBatch = ptsBatchService.getUseBatch(produce.getProduceId());
        if (ptsBatch == null) {
            rj.setResultCode(500);
            rj.setResultMsg("500");
            rj.setResultMsg("系统中没有该产品正在使用的批次,请到管理平台完善");
            return rj;
        }
        /*获取公众号信息*/
        WechatMp wechatMp = produceService.getWechatMpById(produce.getWechatMpId());
        //生成条形码，二维码
        String berQrcode = generationBarCode(produce);
        String json = String.format(NameUtils.QR_LIMIT_STR_SCENE, ResultInfo.barCodePrefix + berQrcode);
        QRCJson qrc = WeixinUtil.createQrcodeByWechatMp(json,wechatMp.getWechatMpAppid(),wechatMp.getWechatMpAppsecret(),wechatMp.getWechatMpPubno());
        PtsMachine ptsMachine = new PtsMachine();
        if (!(qrc == null || qrc.getUrl() == null || qrc.getUrl().isEmpty())) {
            ptsMachine.setMachineQrcode(qrc.getUrl());//二维码
            ptsMachine.setMachineBarcode(berQrcode);//条形码
            ptsMachine.setMachineStatus(1);//机器状态
            ptsMachine.setMachineProducedTime(new Date());//生产时间
            ptsMachine.setMachineIsPrint(1);//是否打印1:未打印2:已打印
            ptsMachine.setMachineCompoundImg("合成的图片url");
            ptsMachine.setMachineProcessState(1);//生成流程状态1.正常2.异常
            ptsMachine.setMachineCreateTime(new Date());//创建时间
            ptsMachine.setMachineProduceType(produce.getProduceType());//产品类型
            ptsMachine.setMachineNfcId(nfcId);
            //ptsMachine.setMachineHardwareVersion(30);
            ptsMachine.setMachineSoftwareVersion(ptsBatch.getBatchSoftwareVersionId());
            ptsMachine.setMachineProduceId(produce.getProduceId());
            ptsMachine.setMachineBomId(0);//默认为0
            ptsMachine.setMachineBatchId(0);//默认为0
            ptsMachine.setMachineIsRetreading(2);
            ptsMachine.setMachineLine(employeeLine); //拉线信息
            ptsMachine.setMachineBatchId(ptsBatch.getBatchId());  //批次id
            ptsMachine.setMachineBomId(ptsBatch.getBomId());    //bom单id
            machineService.addMachine(ptsMachine);
        }
        boolean isAbnormality = true;//状态是否异常

        List<PtsMachineLogs>  ptsMachineLogsList = new ArrayList<PtsMachineLogs>();
        for (int i = 0; i < nodes.size(); i++) {
            PtsMachineLogs ptsMachineLogs = new PtsMachineLogs();

            JSONObject jsonObject = nodes.getJSONObject(i);
            String processNo = jsonObject.getString("processId"); //工序编号
            String nodeNo = jsonObject.getString("nodeId"); //工序选项编号
            String logsProcessTime = jsonObject.getString("logsProcessTime"); //工序执行时间 （时间戳）
            Date logsProcessDate = timeConversions(logsProcessTime);

            ProduceProcess produceProcess = produceService.getProduceProcessAndNode(produce.getProduceId(), processNo);
            ProcessNode processNode = produceService.getprocessNode(produceProcess.getProcessId(), nodeNo);
            String deviceName = produceProcess.getDeviceName();
            String employeeName = produceProcess.getEmployeeName();

            if (deviceName == null) {
                String processName = produceProcess.getProcessName();
                rj.setResultCode(500);
                rj.setResultMsg("500");
                rj.setResultMsg("\"" + processName + "\"工序的打卡设备未完善，请到管理平台完善");
                return rj;
            }
            if (employeeName == null) {
                String processName = produceProcess.getProcessName();
                rj.setResultCode(500);
                rj.setResultMsg("500");
                rj.setResultMsg("\"" + processName + "\"工序的员工信息未完善，请到管理平台完善");
                return rj;
            }

            ptsMachineLogs.setDeviceId(produceProcess.getDriveId());
            ptsMachineLogs.setEmployeeId(produceProcess.getEmployeeId());
            ptsMachineLogs.setProduceId(produce.getProduceId());
            ptsMachineLogs.setProcessId(produceProcess.getProcessId());
            ptsMachineLogs.setMachineId(ptsMachine.getMachineId());
            ptsMachineLogs.setEmployeeName(employeeName);
            ptsMachineLogs.setProduceName(produce.getProduceName());
            ptsMachineLogs.setProcessName(produceProcess.getProcessName());
            ptsMachineLogs.setDeviceName(deviceName);
            ptsMachineLogs.setProcessNodeId(processNode.getNodeId());
            ptsMachineLogs.setProcessNodeName(processNode.getNodeDes());
            if (i == 0) {//如果当前循环的是第一条数据则排序必须是1，否则为异常
                if (produceProcess.getProcessSort() == 1) {
                    if (processNode.getNodeStatus() == 0) {//工序选项状态为异常则机器表状态也是异常
                        isAbnormality = false;
                    }
                    ptsMachineLogs.setLogsProcessStatus(processNode.getNodeStatus());
                } else {
                    ptsMachineLogs.setLogsProcessStatus(0);
                    isAbnormality = false;
                }
            } else {//默认为正常
                ptsMachineLogs.setLogsProcessStatus(processNode.getNodeStatus());
            }
            ptsMachineLogs.setLogsProcessPrompt(processNode.getNodeStatus() == 0 ? "检查不通过" : null);
            ptsMachineLogs.setLogsProcessTime(logsProcessDate);
            ptsMachineLogs.setLogsCreateTime(new Date());

            //根据上一条工序选项信息判断当前工序是否正常，如果当前为修理工序则忽略，如果上一条为修理工序则查询上上一条
            if (i > 0) {
                int num = 0;
                ProduceProcess produceProcess2 = null;//当前工序的上一条非修理工序
                JSONObject jsonObject2;//上一级工序信息
                String processNo2 = null;//上一级工序编号
                //先判断当前的上一次是否是修理工序，如果不是则不用执行下面的循环，否则需要循环判断
                jsonObject2 = nodes.getJSONObject(i - 1);
                if (jsonObject2 != null) {
                    processNo2 = jsonObject2.getString("processId");
                    produceProcess2 = produceService.getProduceProcess(produce.getProduceId(), processNo2);
                    //判断当前工序是否是修理工序，如果是，则修改上一条为次品
                    if (produceProcess.getProcessType() == 2) {
                        ptsMachineLogsList.get(ptsMachineLogsList.size()-1).setLogsErrorType(2); //异常类型 1:流程异常 2:次品异常
                        ptsMachineLogsList.get(ptsMachineLogsList.size()-1).setLogsProcessPrompt("次品异常");
//                        ptsMachineLogs.setLogsErrorType(2);
//                        ptsMachineLogs.setLogsProcessPrompt("次品异常");
//                        machineLogsService.updateMachineLogs(ptsMachineLogs);
                        isAbnormality = false;
                        ptsMachineLogs.setLogsId(null);
                        ptsMachineLogs.setLogsErrorType(null);
                        ptsMachineLogs.setLogsProcessPrompt(null);
                    } else {
                        //判断是否是修理工序 1:生产工序 2:修理工序
                        if (produceProcess2.getProcessType() == 1) {
                            if (produceProcess.getProcessSort() - produceProcess2.getProcessSort() != 1) {
                                ptsMachineLogs.setLogsProcessStatus(0);
                                ptsMachineLogs.setLogsErrorType(1);//异常类型 1:流程异常 2:次品异常
                                ptsMachineLogs.setLogsProcessPrompt("流程异常");
                                isAbnormality = false;
                            }
                        } else {
                            for (int j = i - 1; j <= i - 1; j--) {
                                if (num == i) {
                                    break;//只能循环 i 次，超出则跳出当前循环
                                }
                                jsonObject2 = nodes.getJSONObject(j);
                                if (jsonObject2 != null) {
                                    processNo2 = jsonObject2.getString("processId");
                                    produceProcess2 = produceService.getProduceProcess(produce.getProduceId(), processNo2);
                                    if (produceProcess2.getProcessType() == 1) {//判断是否是修理工序 1:生产工序 2:修理工序
                                        if (produceProcess.getProcessSort() > produceProcess2.getProcessSort()) {
                                            ptsMachineLogs.setLogsProcessStatus(0);
                                            ptsMachineLogs.setLogsErrorType(1);//异常类型 1:流程异常 2:次品异常
                                            ptsMachineLogs.setLogsProcessPrompt("流程异常");
                                            isAbnormality = false;
                                        }
                                        break;
                                    }
                                }
                                num++;
                            }
                        }
                    }
                }
            }
            //执行添加日志操作
            ptsMachineLogsList.add(ptsMachineLogs);
            ptsMachineLogs.setLogsErrorType(null);//还原为默认值
        }
        machineLogsService.addMachineLogs(ptsMachineLogsList);

        //修改机器信息
        PtsMachine ptsMachine2 = new PtsMachine();
        ptsMachine2.setMachineId(ptsMachine.getMachineId());
        if (!isAbnormality) {
            ptsMachine2.setMachineProcessState(2);//2表示机器生产过程中出现异常
        }
        ptsMachine2.setMachineUpdateTime(new Date());
        ptsMachine2.setMachineProduceId(produce.getProduceId());
        machineService.updateMachine(ptsMachine2);
        //截取条形码尾号（4位）
        rj.addResponseKeyValue("barcodeTail", berQrcode.substring(berQrcode.length() - 4, berQrcode.length()));

        return rj;
    }

    private static Date timeConversions(String time) {
        if (time == null || time.equals("")) {
            return new Date();
        }
        //08311112
        Calendar date = Calendar.getInstance();
        String year = String.valueOf(date.get(Calendar.YEAR));//年
        String months = null;//月
        String sky = null;//天
        String when = null;//时
        String subdivision = null;//分
        months = time.substring(0, 2);
        sky = time.substring(2, 4);
        when = time.substring(4, 6);
        subdivision = time.substring(6, 8);
        time = year + "-" + months + "-" + sky + " " + when + ":" + subdivision;
        Date dates = new Date();
        try {
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
            dates = sdf.parse(time);
        } catch (ParseException e) {
            System.out.println(e.getMessage());
        }

        return dates;
    }


    private String productModel = "1X";//产品型号
    private String productFeatures = "A";//产品特性
    private String softwareVersion = "30";//软件版本

    //生成条形码
    public String generationBarCode(Produce produce) {

        java.text.SimpleDateFormat formatter = new java.text.SimpleDateFormat("yyyy-MM");
        java.util.Date currTime = new java.util.Date();
        String curTime = formatter.format(currTime);
        Calendar cal = Calendar.getInstance();
        int year = cal.get(Calendar.YEAR);
        int month = cal.get(Calendar.MONTH) + 1;
        //获取当前月机器总数
        Integer number = machineService.selectMonthCount(curTime);
        number = number + 1;
        String num = null;
        switch (String.valueOf(number).length()) {
            case 0:
                num = "0001";
                break;
            case 1:
                num = "000" + String.valueOf(number);
                break;
            case 2:
                num = "00" + String.valueOf(number);
                break;
            case 3:
                num = "0" + String.valueOf(number);
                break;
            case 4:
                num = String.valueOf(number);
                break;
        }
        String months = String.valueOf(month);
        if (month < 10) {
            months = "0" + months;
        }

        productModel = produce.getProduceModel();
        productFeatures = produce.getProduceFeature();
        //拼接
        String barcode = productModel + productFeatures + softwareVersion + String.valueOf(year).substring(2, 4) + months + num;
        return barcode;
    }


    /**
     * 根据barcode查询机器信息
     * @param request
     * @return
     */
    @ResponseBody
    @RequestMapping("/getMachineInfo")
    public RespJsonBean getMachineInfo(HttpServletRequest request) {
        RespJsonBean rsj = new RespJsonBean();
        String barCode = request.getParameter("barCode");
        if (barCode == null || barCode.equals("")) {
            return null;
        }
        PtsMachine ptsMachine = machineService.getMachineByBarCode(barCode);
        if(ptsMachine != null){
            rsj.addResponseKeyValue("isBeing",1);
            rsj.addResponseKeyValue("productType",ptsMachine.getMachineProduceType() == 1?"净水机":"冲奶机");
            rsj.addResponseKeyValue("producedTime",ptsMachine.getMachineProducedTime() == null?null:ptsMachine.getMachineProducedTime().getTime());
        }else{
            rsj.addResponseKeyValue("isBeing",2);
        }
        return rsj;
    }
}