jiazx0107@163.com
2023-06-22 a4d556ff6f8191637be669e7884fc3e500021516
igds-inout/src/main/java/com/ld/igds/inout/manager/InoutManager.java
@@ -57,7 +57,6 @@
    @Resource
    private InoutDeviceManager inoutDeviceManager;
    /**
     * 直接从数据库查询,不考虑信息状态
     *
@@ -73,7 +72,7 @@
                    "查询参数不完整,查询失败!");
        }
        //获取三天以内最后一天记录
        // 获取三天以内最后一天记录
        param.setStart(DateUtil.getNewByDay(new Date(), -3));
        param.setType(null);
        param.setProgress(null);
@@ -86,11 +85,13 @@
        }
        if (InoutConstant.PROGRESS_RECORD.equals(result.getProgress())) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(), "当前车辆流程已经结束", result);
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "当前车辆流程已经结束", result);
        }
        if (!InoutConstant.PROGRESS_CARD_BACK.equals(result.getProgress())) {
            return new PageResponse<>(RespCodeEnum.CODE_1008.getCode(), "当前车辆流程不在当前环节,无法执行出库", result);
            return new PageResponse<>(RespCodeEnum.CODE_1008.getCode(),
                    "当前车辆流程不在当前环节,无法执行出库", result);
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000, result);
@@ -126,16 +127,16 @@
                return new PageResponse<>(RespCodeEnum.CODE_0000, result);
            }
            //流程类型验证
            // 流程类型验证
            if (!result.getType().equals(param.getType())) {
                String msg = "流程错误:当前车辆流程为【入库】";
                if (InoutConstant.TYPE_OUT.equals(result.getType())) msg = "流程错误:当前车辆流程为【出库】";
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(), msg, result);
                if (InoutConstant.TYPE_OUT.equals(result.getType()))
                    msg = "流程错误:当前车辆流程为【出库】";
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                        msg, result);
            }
            //流程环节验证
            // 流程环节验证
            if (progress.equals(InoutConstant.PROGRESS_WEIGHT_TAG)) {
                if (result.getProgress().equals(
                        InoutConstant.PROGRESS_WEIGHT_EMPTY)
@@ -167,7 +168,6 @@
        }
    }
    public InoutData inoutProgressQuery(InoutData data) throws Exception {
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
@@ -188,18 +188,19 @@
        InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(
                data.getCompanyId(), data.getDeptId());
        if (inoutSysConf.getNoPassNext().equals(InoutConstant.CHECK_NOPASS_RECORD)) {
        if (inoutSysConf.getNoPassNext().equals(
                InoutConstant.CHECK_NOPASS_RECORD)) {
            // 流程结束
            data.setProgress(InoutConstant.PROGRESS_RECORD);
            data.setCompleteTime(new Date());
        }
        if (inoutSysConf.getNoPassNext().equals(InoutConstant.CHECK_NOPASS_BACK)) {
        if (inoutSysConf.getNoPassNext()
                .equals(InoutConstant.CHECK_NOPASS_BACK)) {
            // 离库收卡
            data.setProgress(InoutConstant.PROGRESS_CARD_BACK);
        }
        return data;
    }
    /**
     * 更新质检信息
@@ -209,11 +210,13 @@
     */
    private CheckUpdateResult updateCheckItems(InoutData data) {
        CheckUpdateResult result = new CheckUpdateResult();
        if (null == data.getCheckItems()) return result;
        if (null == data.getCheckItems())
            return result;
        try {
            // 更新检验项数据
            result = checkStandardManager.updateCheckItems(data.getCheckId(), data.getCompanyId(), data.getCheckItems());
            result = checkStandardManager.updateCheckItems(data.getCheckId(),
                    data.getCompanyId(), data.getCheckItems());
            // 将化验数据存入缓存中
            inoutService.setCheckCache(data);
@@ -232,7 +235,8 @@
     *
     * @return
     */
    private String getNextProgress(String curProgress, String type, InoutSysConf sysConf) {
    private String getNextProgress(String curProgress, String type,
                                   InoutSysConf sysConf) {
        String nextProgress = null;
        List<String> list = null;
        if (InoutConstant.TYPE_IN.equals(type)) {
@@ -258,7 +262,8 @@
     * @param data
     * @return
     */
    private InoutData updateBasicInfo(InoutData data, String curProgress, String nextProgress) {
    private InoutData updateBasicInfo(InoutData data, String curProgress,
                                      String nextProgress) {
        if (InoutConstant.PROGRESS_REGISTER.equals(curProgress)) {
            data.setRegisterTime(new Date());
@@ -291,7 +296,7 @@
            data.setProgress(nextProgress);
        }
        //如果下一个数据状态=流程结束,直接补充完整信息
        // 如果下一个数据状态=流程结束,直接补充完整信息
        if (InoutConstant.PROGRESS_RECORD.equals(nextProgress)) {
            data.setCompleteTime(DateUtils.addMinutes(new Date(), 2));
            data.setCompleteUser(ContextUtil.getLoginUserCName());
@@ -370,8 +375,8 @@
        return data;
    }
    public PageResponse<InoutData> submitComplete(InoutData data) throws Exception {
    public PageResponse<InoutData> submitComplete(InoutData data)
            throws Exception {
        if (StringUtils.isEmpty(data.getId())
                || StringUtils.isEmpty(data.getType())
@@ -380,7 +385,6 @@
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到车辆信息。", data);
        }
        data.setUpdateTime(new Date());
        if (null == data.getCompleteTime()) {
@@ -402,7 +406,6 @@
        param.setCompleteTime(data.getCompleteTime());
        param.setProgress(InoutConstant.PROGRESS_RECORD);
        String msg = inoutService.toComplete(param);
        if (null != msg) {
@@ -420,18 +423,18 @@
     */
    public PageResponse<InoutData> submitCardBack(InoutData data) {
        try {
            //如果当前数据已经结束
            // 如果当前数据已经结束
            if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
                //删除缓存
                inoutService.delFromCache(data.getDeptId(), data.getType(), data.getId());
                // 删除缓存
                inoutService.delFromCache(data.getDeptId(), data.getType(),
                        data.getId());
                return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(),
                        "当车辆流程已经完成,卡片已回收", data);
            }
            //如果当前流程不是卡回收
            // 如果当前流程不是卡回收
            if (!InoutConstant.PROGRESS_CARD_BACK.equals(data.getProgress())) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
@@ -447,649 +450,670 @@
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "后端执行异常:" + e.getMessage());
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(),
                "执行成功", data);
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
                data);
    }
    /**
     * 补单操作 补单因为完成时间不确定,所以需要系统根据当前数据进行自动检测,调整原来流水信息和库存
     *
     * @param data
     * @return
     * @throws Exception
     */
    public String addInoutData(InoutData data) throws Exception {
        /**
         * 补单操作 补单因为完成时间不确定,所以需要系统根据当前数据进行自动检测,调整原来流水信息和库存
         *
         * @param data
         * @return
         * @throws Exception
         */
        public String addInoutData(InoutData data) throws Exception {
            if (data.getSettleWeight() <= 0.0) {
                return "补单数据要求结算重量必须大于0";
            }
            // 补单数据直接到结果状态
            data.setRecordStatus(InoutConstant.RECORD_STATUS_ADD);
            data.setProgress(InoutConstant.PROGRESS_RECORD);
            if (InoutConstant.STATUS_NONE.equals(data.getCheckStatus())) {
                data.setCheckStatus(InoutConstant.STATUS_PASS);
            }
            String loginUser = ContextUtil.getLoginUserCName();
            data.setRegisterUser(loginUser);
            data.setFullWeightUser(loginUser);
            data.setEmptyWeightUser(loginUser);
            data.setHandleUser(loginUser);
            data.setCompleteUser(loginUser);
            if (null == data.getCompleteTime()) {
                data.setCompleteTime(new Date());
            }
            // 注册时间比完成时间早一个小时
            data.setRegisterTime(DateUtil.getNewByMinute(new Date(), -60));
            if (StringUtils.isEmpty(data.getUserId())) {
                data.setUserId(InoutConstant.DEFAULT_ID_CARD);
            }
            if (null == data.getIntelCard()) {
                data.setIntelCard(data.getUserId());
            }
            if (null != data.getCheckItems()) {
                data.setCheckUser(loginUser);
            }
            // 保存检测项目
            if (InoutConstant.TYPE_IN.equals(data.getType())) {
                if (null == data.getFullWeightTime()) {
                    data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -50));
                }
                if (null == data.getEmptyWeightTime()) {
                    data.setEmptyWeightTime(DateUtil.getNewByMinute(new Date(), -10));
                }
                // 先执行化验信息保存
                CheckUpdateResult checkResult = checkStandardManager.updateCheckItems(data.getCheckId(), data.getCompanyId(), data.getCheckItems());
                if (null != checkResult) {
//            if (null == data.getWet())data.setWet(checkResult.getWet());
//            if (null == data.getImpurity())data.setImpurity(checkResult.getImpurity());
                }
            } else {
                if (null == data.getEmptyWeightTime()) {
                    data.setEmptyWeightTime(DateUtil.getNewByMinute(new Date(), -50));
                }
                if (null == data.getFullWeightTime()) {
                    data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -10));
                }
            }
            // 添加补单数据
            String msg = inoutService.insertData(data);
            // 初始化验证出入库库存
            commonService.initInoutDepotStore(data);
            return msg;
        if (data.getSettleWeight() <= 0.0) {
            return "补单数据要求结算重量必须大于0";
        }
        /**
         * 修改操作 修改逻辑说明:修改数据需要获取原数据库中的数据进行对比。
         *
         * @param data
         * @return
         * @throws Exception
         */
        @Transactional
        public String updateInoutData(InoutData data)throws Exception {
            if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
                return "系统:已经删除的数据不支持修改!";
            }
            if (InoutConstant.RECORD_STATUS_ERROR.equals(data.getRecordStatus())) {
                return "系统:异常终止的数据不支持修改!";
            }
            // 如果流程未结束,只更新数据
            if (!InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
                return inoutService.updateData(data);
            }
            // 如果是已经完成的数据,先获取到修改直接的数据根据数据进行对比
            InoutParam param = new InoutParam();
            param.setId(data.getId());
            param.setCompanyId(data.getCompanyId());
            param.setType(data.getType());
            InoutData record = inoutService.inoutQueryById(param);
            if (null == record) {
                return "当前修改数据已经不存在!";
            }
            // 避免数据库中的数据已经被其他人修改
            if (InoutConstant.RECORD_STATUS_DEL.equals(record.getRecordStatus())) {
                return "系统:已经删除的数据不支持修改!";
            }
            if (InoutConstant.RECORD_STATUS_ERROR.equals(record.getRecordStatus())) {
                return "系统:异常终止的数据不支持修改!";
            }
            // 保存检测项目
            if (InoutConstant.TYPE_IN.equals(data.getType())) {
                // 先执行化验信息保存
                CheckUpdateResult checkResult = checkStandardManager
                        .updateCheckItems(data.getCheckId(), data.getCompanyId(),
                                data.getCheckItems());
                if (null != checkResult) {
//            if (null == data.getWet())
//               data.setWet(checkResult.getWet());
//            if (null == data.getImpurity())
//               data.setImpurity(checkResult.getImpurity());
                }
            }
            // 更新数据
            inoutService.updateData(data);
            return null;
        // 补单数据直接到结果状态
        data.setRecordStatus(InoutConstant.RECORD_STATUS_ADD);
        data.setProgress(InoutConstant.PROGRESS_RECORD);
        if (InoutConstant.STATUS_NONE.equals(data.getCheckStatus())) {
            data.setCheckStatus(InoutConstant.STATUS_PASS);
        }
        /**
         * 删除操作 删除数据为软删除,删除数据后需要根据删除情况联动库存等信息
         *
         * @param data
         * @param selected 是否已经查询过数据
         * @return
         * @throws Exception
         */
        @Transactional
        public String delInoutData (InoutData data,boolean selected)
        String loginUser = ContextUtil.getLoginUserCName();
        data.setRegisterUser(loginUser);
        data.setFullWeightUser(loginUser);
        data.setEmptyWeightUser(loginUser);
        data.setHandleUser(loginUser);
        data.setCompleteUser(loginUser);
        if (null == data.getCompleteTime()) {
            data.setCompleteTime(new Date());
        }
        // 注册时间比完成时间早一个小时
        data.setRegisterTime(DateUtil.getNewByMinute(new Date(), -60));
        if (StringUtils.isEmpty(data.getUserId())) {
            data.setUserId(InoutConstant.DEFAULT_ID_CARD);
        }
        if (null == data.getIntelCard()) {
            data.setIntelCard(data.getUserId());
        }
        if (null != data.getCheckItems()) {
            data.setCheckUser(loginUser);
        }
        // 保存检测项目
        if (InoutConstant.TYPE_IN.equals(data.getType())) {
            if (null == data.getFullWeightTime()) {
                data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -50));
            }
            if (null == data.getEmptyWeightTime()) {
                data.setEmptyWeightTime(DateUtil
                        .getNewByMinute(new Date(), -10));
            }
            // 先执行化验信息保存
            CheckUpdateResult checkResult = checkStandardManager
                    .updateCheckItems(data.getCheckId(), data.getCompanyId(),
                            data.getCheckItems());
            if (null != checkResult) {
                // if (null == data.getWet())data.setWet(checkResult.getWet());
                // if (null ==
                // data.getImpurity())data.setImpurity(checkResult.getImpurity());
            }
        } else {
            if (null == data.getEmptyWeightTime()) {
                data.setEmptyWeightTime(DateUtil
                        .getNewByMinute(new Date(), -50));
            }
            if (null == data.getFullWeightTime()) {
                data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -10));
            }
        }
        // 添加补单数据
        String msg = inoutService.insertData(data);
        // 初始化验证出入库库存
        commonService.initInoutDepotStore(data);
        return msg;
    }
    /**
     * 修改操作 修改逻辑说明:修改数据需要获取原数据库中的数据进行对比。
     *
     * @param data
     * @return
     * @throws Exception
     */
    @Transactional
    public String updateInoutData(InoutData data) throws Exception {
        if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
            return "系统:已经删除的数据不支持修改!";
        }
        if (InoutConstant.RECORD_STATUS_ERROR.equals(data.getRecordStatus())) {
            return "系统:异常终止的数据不支持修改!";
        }
        // 如果流程未结束,只更新数据
        if (!InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            return inoutService.updateData(data);
        }
        // 如果是已经完成的数据,先获取到修改直接的数据根据数据进行对比
        InoutParam param = new InoutParam();
        param.setId(data.getId());
        param.setCompanyId(data.getCompanyId());
        param.setType(data.getType());
        InoutData record = inoutService.inoutQueryById(param);
        if (null == record) {
            return "当前修改数据已经不存在!";
        }
        // 避免数据库中的数据已经被其他人修改
        if (InoutConstant.RECORD_STATUS_DEL.equals(record.getRecordStatus())) {
            return "系统:已经删除的数据不支持修改!";
        }
        if (InoutConstant.RECORD_STATUS_ERROR.equals(record.getRecordStatus())) {
            return "系统:异常终止的数据不支持修改!";
        }
        // 保存检测项目
        if (InoutConstant.TYPE_IN.equals(data.getType())) {
            // 先执行化验信息保存
            CheckUpdateResult checkResult = checkStandardManager
                    .updateCheckItems(data.getCheckId(), data.getCompanyId(),
                            data.getCheckItems());
            if (null != checkResult) {
                // if (null == data.getWet())
                // data.setWet(checkResult.getWet());
                // if (null == data.getImpurity())
                // data.setImpurity(checkResult.getImpurity());
            }
        }
        // 更新数据
        inoutService.updateData(data);
        return null;
    }
    /**
     * 删除操作 删除数据为软删除,删除数据后需要根据删除情况联动库存等信息
     *
     * @param data
     * @param selected 是否已经查询过数据
     * @return
     * @throws Exception
     */
    @Transactional
    public String delInoutData(InoutData data, boolean selected)
            throws Exception {
            // 避免页面缓存首先获取数据库中最新的当前数据信息
            InoutParam param = new InoutParam();
            param.setCompanyId(data.getCompanyId());
            param.setId(data.getId());
            param.setMsg(" [" + ContextUtil.getLoginUserCName() + "]执行删除,原因:"
                    + data.getRemarks());
        // 避免页面缓存首先获取数据库中最新的当前数据信息
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setId(data.getId());
        param.setMsg(" [" + ContextUtil.getLoginUserCName() + "]执行删除,原因:"
                + data.getRemarks());
            if (!selected) {
                data = inoutService.inoutQueryById(param);
                if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
                    return "已经删除的数据,不支持重复删除!";
                }
                if (InoutConstant.RECORD_STATUS_ERROR
                        .equals(data.getRecordStatus())) {
                    return "当前数据已经被标记为异常,不支持删除!";
                }
            }
            // 执行删除
            param.setProgress(InoutConstant.PROGRESS_RECORD);
            param.setRecordStatus(InoutConstant.RECORD_STATUS_DEL);
            param.setType(data.getType());
            inoutService.deleteData(param);
            // 如果流程未结束,直接删除,不牵扯到联动调整
            if (!InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
                return null;
            }
            return null;
        }
        /**
         * 异常终止操作 设置异常 为了避免页面数据缓存,需要重新获取最新数据判断
         *
         * @param data
         * @return
         * @throws Exception
         */
        @Transactional
        public String errorInoutData (InoutData data){
            InoutParam param = new InoutParam();
            param.setCompanyId(data.getCompanyId());
            param.setId(data.getId());
            param.setMsg(" [" + ContextUtil.getLoginUserCName() + "]执行异常终止,原因:"
                    + data.getRemarks());
        if (!selected) {
            data = inoutService.inoutQueryById(param);
            if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
                return "已经删除的数据,不支持异常处理!";
                return "已经删除的数据,不支持重复删除!";
            }
            if (InoutConstant.RECORD_STATUS_ERROR.equals(data.getRecordStatus())) {
                return "不支持重复异常处理!";
            if (InoutConstant.RECORD_STATUS_ERROR
                    .equals(data.getRecordStatus())) {
                return "当前数据已经被标记为异常,不支持删除!";
            }
            if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
                return "流程结束的数据不支持异常处理!";
            }
            return inoutService.inoutStop(param);
        }
        /**
         * 快速结束操作 流程没有结束的单据进行结束
         *
         * @param data
         * @return
         */
        public String completeInoutData (InoutData data) throws Exception {
            if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
                return "已经删除的数据,不支持完成!";
            }
            if (InoutConstant.RECORD_STATUS_ERROR.equals(data.getRecordStatus())) {
                return "异常终止的数据,不支持完成!";
            }
            if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
                return "流程已完成的数据,不支持完成!";
            }
        // 执行删除
        param.setProgress(InoutConstant.PROGRESS_RECORD);
        param.setRecordStatus(InoutConstant.RECORD_STATUS_DEL);
        param.setType(data.getType());
        inoutService.deleteData(param);
            // 从新查询数据
        // 如果流程未结束,直接删除,不牵扯到联动调整
        if (!InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            return null;
        }
        return null;
    }
    /**
     * 异常终止操作 设置异常 为了避免页面数据缓存,需要重新获取最新数据判断
     *
     * @param data
     * @return
     * @throws Exception
     */
    @Transactional
    public String errorInoutData(InoutData data) {
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setId(data.getId());
        param.setMsg(" [" + ContextUtil.getLoginUserCName() + "]执行异常终止,原因:"
                + data.getRemarks());
        data = inoutService.inoutQueryById(param);
        if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
            return "已经删除的数据,不支持异常处理!";
        }
        if (InoutConstant.RECORD_STATUS_ERROR.equals(data.getRecordStatus())) {
            return "不支持重复异常处理!";
        }
        if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            return "流程结束的数据不支持异常处理!";
        }
        return inoutService.inoutStop(param);
    }
    /**
     * 快速结束操作 流程没有结束的单据进行结束
     *
     * @param data
     * @return
     */
    public String completeInoutData(InoutData data) throws Exception {
        if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
            return "已经删除的数据,不支持完成!";
        }
        if (InoutConstant.RECORD_STATUS_ERROR.equals(data.getRecordStatus())) {
            return "异常终止的数据,不支持完成!";
        }
        if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            return "流程已完成的数据,不支持完成!";
        }
        // 从新查询数据
        InoutParam param = new InoutParam();
        param.setId(data.getId());
        param.setCompanyId(data.getCompanyId());
        param.setType(data.getType());
        InoutData cuData = inoutService.inoutProgressQuery(param);
        if (null == cuData) {
            return "当前车辆流程状态已经变化,请刷新页面重新操作!";
        }
        if (!cuData.getProgress().equals(data.getProgress())) {
            return "当前车辆流程状态已经变化,请刷新页面重新操作!";
        }
        if (null == data.getCompleteTime()) {
            return "请填写完成时间!!";
        }
        if (StringUtils.isEmpty(data.getDepotId())) {
            return "请填写仓库信息!";
        }
        if (StringUtils.isEmpty(data.getFoodYear())) {
            return "请填写粮食年份信息!";
        }
        if (StringUtils.isEmpty(data.getFoodVariety())) {
            return "请填写粮食品种信息!";
        }
        if (data.getSettleWeight() <= 0) {
            return "请填写结算净重信息!";
        }
        String msg = inoutService.quickComplete(data);
        if (null == msg) {
            data.setProgress(InoutConstant.PROGRESS_RECORD);
            commonService.initInoutDepotStore(data);
        }
        return msg;
    }
    public void initLpr(InoutConf conf) {
        inoutDeviceManager.initLpr(conf);
    }
    /**
     * 出入库注册数据提交,入库登记和出入库登记使用同一个方法
     *
     * @param data
     * @return
     * @throws Exception
     */
    public PageResponse<InoutData> submitRegisterInout(InoutData data)
            throws Exception {
        // 首先判断流程中是否有已经存在的车辆信息未执行完成,直接从数据库中查询
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setPlateNum(data.getPlateNum());
        param.setIntelCard(data.getIntelCard());
        param.setType(data.getType());
        param.setStart(DateUtil.getNewByDay(null, -10));
        int num = inoutService.checkExist(param);
        if (num > 0) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前车牌或智慧卡有正在执行流程未结束,请联系管理员", data);
        }
        // 获取系统参数配置
        InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(
                data.getCompanyId(), data.getDeptId());
        if (null == inoutSysConf) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "提示:当前库区未配置出入库流程信息,请联系管理员", data);
        }
        // 获取下一个流程状态
        String curProgress = data.getProgress();
        String nextProgress = getNextProgress(curProgress, data.getType(),
                inoutSysConf);
        data = updateBasicInfo(data, curProgress, nextProgress);
        String msg = inoutService.insertData(data);
        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg,
                    data);
        }
        // 执行附件信息
        fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(),
                data.getId(), curProgress);
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
                data);
    }
    public PageResponse<InoutData> submitWeightIn(InoutData data)
            throws Exception {
        // 获取系统参数配置
        InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(
                data.getCompanyId(), data.getDeptId());
        if (null == inoutSysConf) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "提示:当前系统中流程配置异常,请联系管理员", data);
        }
        // 获取下一个流程状态
        String curProgress = data.getProgress();
        String nextProgress = getNextProgress(curProgress, data.getType(),
                inoutSysConf);
        data = updateBasicInfo(data, curProgress, nextProgress);
        // 入库称重可能调整质检单
        CheckUpdateResult checkUpdateResult = updateCheckItems(data);
        if (data.getDeCheck() == 0) {
            data.setDeCheck(checkUpdateResult.getDeSum());
        }
        if (data.getAddCheck() == 0) {
            data.setAddCheck(checkUpdateResult.getAddSum());
        }
        // 执行数据更新
        String msg = inoutService.updateData(data);
        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg,
                    data);
        }
        // 执行附件信息
        fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(),
                data.getId(), curProgress);
        // 称重完成,调用出入库控制逻辑处理
        inoutDeviceManager.controlWeight(data, curProgress, nextProgress);
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
                data);
    }
    public PageResponse<InoutData> submitWeightOut(InoutData data)
            throws Exception {
        // 获取系统参数配置
        InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(
                data.getCompanyId(), data.getDeptId());
        if (null == inoutSysConf) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "提示:当前系统中流程配置异常,请联系管理员", data);
        }
        // 获取下一个流程状态
        String curProgress = data.getProgress();
        String nextProgress = getNextProgress(curProgress, data.getType(),
                inoutSysConf);
        data = updateBasicInfo(data, curProgress, nextProgress);
        // 执行数据更新
        String msg = inoutService.updateData(data);
        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg,
                    data);
        }
        // 执行附件信息
        fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(),
                data.getId(), curProgress);
        // 称重后根据当前流程状态和下一个状态,通知称重控制器
        inoutDeviceManager.controlWeight(data, curProgress, nextProgress);
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
                data);
    }
    public PageResponse<InoutData> submitHandle(InoutData data)
            throws Exception {
        if (null == data.getHandleUser()) {
            data.setHandleUser(ContextUtil.getLoginUserCName());
        }
        // 获取系统参数配置
        InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(
                data.getCompanyId(), data.getDeptId());
        if (null == inoutSysConf) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "提示:当前系统中流程配置异常,请联系管理员", data);
        }
        // 获取下一个流程状态
        String curProgress = data.getProgress();
        String nextProgress = getNextProgress(curProgress, data.getType(),
                inoutSysConf);
        data = updateBasicInfo(data, curProgress, nextProgress);
        // 执行数据更新
        String msg = inoutService.updateDataByHandle(data);
        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg,
                    data);
        }
        // 执行附件信息
        fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(),
                data.getId(), curProgress);
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
                data);
    }
    /**
     * 根据条件获取扦样数据
     *
     * @param param
     * @return
     */
    public PageResponse<Page<InoutCheckData>> pageSampleData(
            InoutCheckParam param) {
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(param.getDeptId())) {
            param.setDeptId(ContextUtil.subDeptId(null));
        }
        // 若查询条件为已扦样,则流程置空;若未扦样,则流程不处理,仍为扦样化验流程(CHECK)
        if (!"NONE".equals(param.getSampleStatus())) {
            param.setProgress(null);
        }
        // 获取扦样数据
        Page<InoutCheckData> sampleList = inoutService.pageSampleData(param);
        if (null == sampleList.getRecords()
                || sampleList.getRecords().isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "获取到数据信息为空");
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000, sampleList);
    }
    public PageResponse<InoutCheckData> submitSample(InoutCheckData data) throws Exception {
        // 获取业务数据信息
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setId(data.getId());
        InoutData curData = inoutService.inoutProgressQuery(param);
        if (null == curData) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "没有获取到入库业务数据信息,更新失败", data);
        }
        if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前流程已经结束,不支持修改");
        }
        // 扦样时间和扦样人
        if (StringUtils.isEmpty(data.getSampleUser())) {
            data.setSampleUser(ContextUtil.getLoginUserCName());
        }
        if (null == data.getSampleTime()) {
            data.setSampleTime(new Date());
        }
        String msg = inoutService.updateSampleData(data);
        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功");
    }
    /**
     * @param param
     * @return
     */
    public PageResponse<Page<InoutCheckData>> pageCheckData(
            InoutCheckParam param) {
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(param.getDeptId())) {
            param.setDeptId(ContextUtil.subDeptId(null));
        }
        // 如果是已化验,则将流程状态置空,如果是未化验,则流程状态不处理,仍是CHECK状态
        if (!"NONE".equals(param.getCheckStatus())) {
            param.setProgress(null);
        }
        Page<InoutCheckData> checkList = inoutService.pageCheckData(param);
        if (null == checkList.getRecords() || checkList.getRecords().isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "获取到数据信息为空");
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000, checkList);
    }
    /**
     * 获取化验项信息
     *
     * @param param
     * @return
     */
    public PageResponse<List<CheckItemData>> getCheckItemData(
            InoutCheckParam param) {
        try {
            List<CheckItemData> result = checkStandardManager.listCheckItem(
                    param.getCheckId(), param.getCompanyId(),
                    param.getFoodVariety());
            return new PageResponse<>(RespCodeEnum.CODE_0000, result);
        } catch (Exception e) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), "后台异常:"
                    + e.getMessage(), null);
        }
    }
    @Transactional(rollbackFor = Exception.class)
    public PageResponse<InoutCheckData> updateCheckData(InoutCheckData data) {
        try {
            // 获取业务数据信息
            InoutParam param = new InoutParam();
            param.setCompanyId(data.getCompanyId());
            param.setId(data.getId());
            param.setCompanyId(data.getCompanyId());
            param.setType(data.getType());
            InoutData cuData = inoutService.inoutProgressQuery(param);
            if (null == cuData) {
                return "当前车辆流程状态已经变化,请刷新页面重新操作!";
            }
            if (!cuData.getProgress().equals(data.getProgress())) {
                return "当前车辆流程状态已经变化,请刷新页面重新操作!";
            }
            if (null == data.getCompleteTime()) {
                return "请填写完成时间!!";
            }
            if (StringUtils.isEmpty(data.getDepotId())) {
                return "请填写仓库信息!";
            }
            if (StringUtils.isEmpty(data.getFoodYear())) {
                return "请填写粮食年份信息!";
            }
            if (StringUtils.isEmpty(data.getFoodVariety())) {
                return "请填写粮食品种信息!";
            }
            if (data.getSettleWeight() <= 0) {
                return "请填写结算净重信息!";
            }
            String msg = inoutService.quickComplete(data);
            if (null == msg) {
                data.setProgress(InoutConstant.PROGRESS_RECORD);
                commonService.initInoutDepotStore(data);
            }
            return msg;
        }
        public void initLpr (InoutConf conf){
            inoutDeviceManager.initLpr(conf);
        }
        /**
         * 出入库注册数据提交,入库登记和出入库登记使用同一个方法
         *
         * @param data
         * @return
         * @throws Exception
         */
        public PageResponse<InoutData> submitRegisterInout (InoutData data) throws Exception {
            //首先判断流程中是否有已经存在的车辆信息未执行完成,直接从数据库中查询
            InoutParam param = new InoutParam();
            param.setCompanyId(data.getCompanyId());
            param.setPlateNum(data.getPlateNum());
            param.setIntelCard(data.getIntelCard());
            param.setType(data.getType());
            param.setStart(DateUtil.getNewByDay(null, -10));
            int num = inoutService.checkExist(param);
            if (num > 0) {
            InoutData curData = inoutService.inoutProgressQuery(param);
            if (null == curData) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "当前车牌或智慧卡有正在执行流程未结束,请联系管理员", data);
                        "没有获取到入库业务数据信息,更新失败", data);
            }
            if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "当前流程已经结束,不支持修改");
            }
            // 更新化验项信息
            CheckUpdateResult checkResult = checkStandardManager
                    .updateCheckItems(data.getCheckId(), data.getCompanyId(),
                            data.getCheckItems());
            if (StringUtils.isNotEmpty(checkResult.getMsg())) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "后台执行异常:" + checkResult.getMsg(), data);
            }
            //获取系统参数配置
            InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());
            // 设置化验信息
            if (checkResult.getDeSum() > 0) {
                data.setDeCheck(checkResult.getDeSum());
            }
            if (checkResult.getAddSum() > 0) {
                data.setAddCheck(checkResult.getAddSum());
            }
            if (null == data.getCheckTime()) {
                data.setCheckTime(new Date());
            }
            curData.setCheckStatus(data.getCheckStatus());
            // 获取系统参数配置
            InoutSysConf inoutSysConf = inoutCommonService
                    .getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());
            if (null == inoutSysConf) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "提示:当前库区未配置出入库流程信息,请联系管理员", data);
            }
            // 更新下一流程状态
            if (InoutConstant.PROGRESS_CHECK.equals(curData.getProgress())) {
                curData = updateBasicInfo(curData, inoutSysConf);
                // 若化验结果不合格,判断配置后续流程
                if (InoutConstant.STATUS_UNPASS
                        .equals(curData.getCheckStatus())) {
                    curData = checkNoPass(curData);
                }
            }
            // 化验人、化验时间
            data.setCheckStatus(curData.getCheckStatus());
            data.setProgress(curData.getProgress());
            if (StringUtils.isEmpty(data.getCheckUser())) {
                data.setCheckUser(ContextUtil.getLoginUserCName());
            }
            if (null == data.getCheckTime()) {
                data.setCheckTime(new Date());
            }
            //获取下一个流程状态
            String curProgress = data.getProgress();
            String nextProgress = getNextProgress(curProgress, data.getType(), inoutSysConf);
            data = updateBasicInfo(data, curProgress, nextProgress);
            String msg = inoutService.insertData(data);
            String msg = inoutService.updateCheckData(data);
            if (null != msg) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
            }
            return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功");
        } catch (Exception e) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), "后台异常:"
                    + e.getMessage(), null);
        }
    }
    /**
     * 获取单价信息
     *
     * @param param
     * @return
     */
    public PageResponse<InoutPrice> getPrice(InoutCheckParam param) {
        try {
            List<InoutPrice> price = inoutService.getPrice(param);
            if (null == price || price.isEmpty()) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        msg, data);
                        "未获取到粮食定价配置信息");
            }
            return new PageResponse<>(RespCodeEnum.CODE_0000, price.get(0));
            // 执行附件信息
            fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(), data.getId(), curProgress);
            return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功", data);
        } catch (Exception e) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), "后台异常:"
                    + e.getMessage(), null);
        }
    }
        public PageResponse<InoutData> submitWeightIn (InoutData data) throws Exception {
            //获取系统参数配置
            InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());
            if (null == inoutSysConf) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "提示:当前系统中流程配置异常,请联系管理员", data);
            }
            //获取下一个流程状态
            String curProgress = data.getProgress();
            String nextProgress = getNextProgress(curProgress, data.getType(), inoutSysConf);
            data = updateBasicInfo(data, curProgress, nextProgress);
            //入库称重可能调整质检单
            CheckUpdateResult checkUpdateResult = updateCheckItems(data);
            if (data.getDeCheck() == 0) {
                data.setDeCheck(checkUpdateResult.getDeSum());
            }
            if (data.getAddCheck() == 0) {
                data.setAddCheck(checkUpdateResult.getAddSum());
            }
            //执行数据更新
            String msg = inoutService.updateData(data);
            if (null != msg) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg, data);
            }
            // 执行附件信息
            fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(), data.getId(), curProgress);
            //称重完成,调用出入库控制逻辑处理
            inoutDeviceManager.controlWeight(data, curProgress, nextProgress);
            return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功", data);
        }
        public PageResponse<InoutData> submitWeightOut (InoutData data) throws Exception {
            //获取系统参数配置
            InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());
            if (null == inoutSysConf) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "提示:当前系统中流程配置异常,请联系管理员", data);
            }
            //获取下一个流程状态
            String curProgress = data.getProgress();
            String nextProgress = getNextProgress(curProgress, data.getType(), inoutSysConf);
            data = updateBasicInfo(data, curProgress, nextProgress);
            //执行数据更新
            String msg = inoutService.updateData(data);
            if (null != msg) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg, data);
            }
            // 执行附件信息
            fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(), data.getId(), curProgress);
            //称重后根据当前流程状态和下一个状态,通知称重控制器
            inoutDeviceManager.controlWeight(data, curProgress, nextProgress);
            return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功", data);
        }
        public PageResponse<InoutData> submitHandle (InoutData data) throws Exception {
            if (null == data.getHandleUser()) {
                data.setHandleUser(ContextUtil.getLoginUserCName());
            }
            //获取系统参数配置
            InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());
            if (null == inoutSysConf) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "提示:当前系统中流程配置异常,请联系管理员", data);
            }
            //获取下一个流程状态
            String curProgress = data.getProgress();
            String nextProgress = getNextProgress(curProgress, data.getType(), inoutSysConf);
            data = updateBasicInfo(data, curProgress, nextProgress);
            //执行数据更新
            String msg = inoutService.updateDataByHandle(data);
            if (null != msg) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg, data);
            }
            // 执行附件信息
            fileService.saveInoutFiles(data.getFiles(), data.getCompanyId(), data.getId(), curProgress);
            return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功", data);
        }
        /**
         * 根据条件获取扦样数据
         *
         * @param param
         * @return
         */
        public PageResponse<Page<InoutCheckData>> pageSampleData (InoutCheckParam param){
            if (StringUtils.isEmpty(param.getCompanyId())) {
                param.setCompanyId(ContextUtil.getCompanyId());
            }
            if (StringUtils.isEmpty(param.getDeptId())) {
                param.setDeptId(ContextUtil.subDeptId(null));
            }
            //若查询条件为已扦样,则流程置空;若未扦样,则流程不处理,仍为扦样化验流程(CHECK)
            if (!"NONE".equals(param.getSampleStatus())) {
                param.setProgress(null);
            }
            //获取扦样数据
            Page<InoutCheckData> sampleList = inoutService.pageSampleData(param);
            if (null == sampleList.getRecords() || sampleList.getRecords().isEmpty()) {
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                        "获取到数据信息为空");
            }
            return new PageResponse<>(RespCodeEnum.CODE_0000, sampleList);
        }
        @Transactional(rollbackFor = Exception.class)
        public PageResponse<InoutCheckData> updateSampleData (InoutCheckData data){
            try {
                // 获取业务数据信息
                InoutParam param = new InoutParam();
                param.setCompanyId(data.getCompanyId());
                param.setId(data.getId());
                InoutData curData = inoutService.inoutProgressQuery(param);
                if (null == curData) {
                    return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                            "没有获取到入库业务数据信息,更新失败", data);
                }
                if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
                    return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                            "当前流程已经结束,不支持修改");
                }
                //扦样时间和扦样人
                if (StringUtils.isEmpty(data.getSampleUser())) {
                    data.setSampleUser(ContextUtil.getLoginUserCName());
                }
                if (null == data.getSampleTime()) {
                    data.setSampleTime(new Date());
                }
                String msg = inoutService.updateSampleData(data);
                if (null != msg) {
                    return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
                }
                return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功");
            } catch (Exception e) {
                log.error("后台异常:{}", e);
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "后台异常:" + e.getMessage(), null);
            }
        }
        /**
         * @param param
         * @return
         */
        public PageResponse<Page<InoutCheckData>> pageCheckData (InoutCheckParam param){
            if (StringUtils.isEmpty(param.getCompanyId())) {
                param.setCompanyId(ContextUtil.getCompanyId());
            }
            if (StringUtils.isEmpty(param.getDeptId())) {
                param.setDeptId(ContextUtil.subDeptId(null));
            }
            // 如果是已化验,则将流程状态置空,如果是未化验,则流程状态不处理,仍是CHECK状态
            if (!"NONE".equals(param.getCheckStatus())) {
                param.setProgress(null);
            }
            Page<InoutCheckData> checkList = inoutService.pageCheckData(param);
            if (null == checkList.getRecords() || checkList.getRecords().isEmpty()) {
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                        "获取到数据信息为空");
            }
            return new PageResponse<>(RespCodeEnum.CODE_0000, checkList);
        }
        /**
         * 获取化验项信息
         *
         * @param param
         * @return
         */
        public PageResponse<List<CheckItemData>> getCheckItemData (InoutCheckParam param){
            try {
                List<CheckItemData> result = checkStandardManager.listCheckItem(param.getCheckId(),
                        param.getCompanyId(), param.getFoodVariety());
                return new PageResponse<>(RespCodeEnum.CODE_0000, result);
            } catch (Exception e) {
                return new PageResponse<>(
                        RespCodeEnum.CODE_1111.getCode(), "后台异常:" + e.getMessage(), null);
            }
        }
        @Transactional(rollbackFor = Exception.class)
        public PageResponse<InoutCheckData> updateCheckData (InoutCheckData data){
            try {
                // 获取业务数据信息
                InoutParam param = new InoutParam();
                param.setCompanyId(data.getCompanyId());
                param.setId(data.getId());
                InoutData curData = inoutService.inoutProgressQuery(param);
                if (null == curData) {
                    return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                            "没有获取到入库业务数据信息,更新失败", data);
                }
                if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
                    return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                            "当前流程已经结束,不支持修改");
                }
                //更新化验项信息
                CheckUpdateResult checkResult = checkStandardManager.updateCheckItems(data.getCheckId(), data.getCompanyId(), data.getCheckItems());
                if (StringUtils.isNotEmpty(checkResult.getMsg())) {
                    return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                            "后台执行异常:" + checkResult.getMsg(), data);
                }
                //设置化验信息
                if (checkResult.getDeSum() > 0) {
                    data.setDeCheck(checkResult.getDeSum());
                }
                if (checkResult.getAddSum() > 0) {
                    data.setAddCheck(checkResult.getAddSum());
                }
                if (null == data.getCheckTime()) {
                    data.setCheckTime(new Date());
                }
                curData.setCheckStatus(data.getCheckStatus());
                //获取系统参数配置
                InoutSysConf inoutSysConf = inoutCommonService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());
                if (null == inoutSysConf) {
                    return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                            "提示:当前库区未配置出入库流程信息,请联系管理员", data);
                }
                //更新下一流程状态
                if (InoutConstant.PROGRESS_CHECK.equals(curData.getProgress())) {
                    curData = updateBasicInfo(curData, inoutSysConf);
                    // 若化验结果不合格,判断配置后续流程
                    if (InoutConstant.STATUS_UNPASS.equals(curData.getCheckStatus())) {
                        curData = checkNoPass(curData);
                    }
                }
                //化验人、化验时间
                data.setCheckStatus(curData.getCheckStatus());
                data.setProgress(curData.getProgress());
                if (StringUtils.isEmpty(data.getCheckUser())) {
                    data.setCheckUser(ContextUtil.getLoginUserCName());
                }
                if (null == data.getCheckTime()) {
                    data.setCheckTime(new Date());
                }
                String msg = inoutService.updateCheckData(data);
                if (null != msg) {
                    return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
                }
                return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功");
            } catch (Exception e) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "后台异常:" + e.getMessage(), null);
            }
        }
        /**
         * 获取单价信息
         *
         * @param param
         * @return
         */
        public PageResponse<InoutPrice> getPrice (InoutCheckParam param){
            try {
                List<InoutPrice> price = inoutService.getPrice(param);
                if (null == price || price.isEmpty()) {
                    return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), "未获取到粮食定价配置信息");
                }
                return new PageResponse<>(RespCodeEnum.CODE_0000, price.get(0));
            } catch (Exception e) {
                return new PageResponse<>(
                        RespCodeEnum.CODE_1111.getCode(), "后台异常:" + e.getMessage(), null);
            }
        }
    }
}