出入库优化-登记2

jiazx0107@163.com

2023-05-30 2495e9ab75e6c45af1d6e14414711d8cc79fe2ca

出入库优化-登记2

 igds-core/src/main/java/com/ld/igds/file/impl/CoreFileServiceImpl.java

@@ -77,8 +77,7 @@
    public void saveInoutFiles(List<FileData> files, String companyId,
            String bizId, String bizTag) throws Exception, SQLException {

        if (files.size() == 0)
            return;
        if (null == files || files.size() == 0) return;

        for (FileData data : files) {
            // å¦‚果没有附件名称，则不保存附件信息

 igds-core/src/main/java/com/ld/igds/models/InoutSysConf.java

@@ -44,13 +44,13 @@
    @PropertyDef(label = "出库流程配置", description = "使用-线隔开的流程配置")
    private String progressOut;

    @Column(name = "NOTICE_TAG_IN_", length = 1)
    @PropertyDef(label = "入库通知单标记")
    private String noticeTagIn = Constant.YN_Y;

    @Column(name = "NOTICE_TAG_OUT_", length = 1)
    @PropertyDef(label = "出库通知单标记")
    private String noticeTagOut = Constant.YN_Y;
//    @Column(name = "NOTICE_TAG_IN_", length = 1)
//    @PropertyDef(label = "入库通知单标记")
//    private String noticeTagIn = Constant.YN_Y;
//
//    @Column(name = "NOTICE_TAG_OUT_", length = 1)
//    @PropertyDef(label = "出库通知单标记")
//    private String noticeTagOut = Constant.YN_Y;


    @Column(name = "NOTICE_WX_", length = 1)

 igds-inout/src/main/java/com/ld/igds/inout/controller/CheckController.java

@@ -3,9 +3,7 @@
import com.ld.igds.constant.RespCodeEnum;
import com.ld.igds.data.PageResponse;
import com.ld.igds.inout.manager.CheckManager;
import com.ld.igds.io.dto.CheckResultParam;
import com.ld.igds.io.sample.data.SampleDto;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
@@ -21,7 +19,6 @@
 * @data:2020å¹´3月22日
 *
 */
@Slf4j
@RestController
@RequestMapping("api/check")
public class CheckController {

 igds-inout/src/main/java/com/ld/igds/inout/controller/InoutApiController.java

@@ -36,15 +36,13 @@
    @ResponseBody
    @RequestMapping("/get-plateNum")
    public PageResponse<ApiInoutData> getPlateNum(@RequestBody ApiInoutData param) {

        if (StringUtils.isEmpty(param.getProtocol())) {
            param.setErrorMsg("当前车牌识别未配置通讯协议，无法执行");
            return new PageResponse<>(RespCodeEnum.CODE_1007, param);
    	
        if (null == param.getIp()) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(), "出入库配置中没有配置如入登记的车牌识别");
        }

        if (null == param.getIp()) {
            param.setErrorMsg("出入库配置中没有配置如入登记的车牌识别");
            return new PageResponse<>(RespCodeEnum.CODE_1007, param);
        if (StringUtils.isEmpty(param.getProtocol())) {
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(), "当前车牌识别未配置通讯协议，无法执行");
        }

        param = inoutDeviceManager.getPlateNum(param);
@@ -57,9 +55,9 @@
    }

    /**
     * èŽ·å–车牌识别信息
     * èŽ·å–智慧卡信息
     *
     * @param param è½¦ç‰Œè¯†åˆ«æ•°æ®ä¿¡æ¯
     * @param param èŽ·å–智慧卡信息
     * @return
     */
    @ResponseBody
@@ -67,13 +65,11 @@
    public PageResponse<ApiInoutData> getIcCardNum(@RequestBody ApiInoutData param) {

        if (StringUtils.isEmpty(param.getProtocol())) {
            param.setErrorMsg("当前智慧卡未配置通讯协议，无法执行");
            return new PageResponse<>(RespCodeEnum.CODE_1007, param);
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(), "当前智慧卡未配置通讯协议，无法执行");
        }

        if (null == param.getIp()) {
            param.setErrorMsg("出入库配置中没有配置智慧卡信息");
            return new PageResponse<>(RespCodeEnum.CODE_1007, param);
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(), "出入库配置中没有配置智慧卡信息");
        }

        param = inoutDeviceManager.getIcCardNum(param);

 igds-inout/src/main/java/com/ld/igds/inout/controller/InoutController.java

@@ -227,13 +227,13 @@
                InoutConstant.PROGRESS_WEIGHT_TAG, 3);
        view.addObject("snapDto3", conf);

         conf = inoutCommonManager.getInoutConf(listInoutConf, sort, InoutConstant.CONF_TYPE_70,
        conf = inoutCommonManager.getInoutConf(listInoutConf, sort, InoutConstant.CONF_TYPE_70,
                InoutConstant.PROGRESS_WEIGHT_TAG, 1);

        view.addObject("gateDto", conf);
        // æ™ºæ…§å¡
        conf = inoutCommonManager.getInoutConf(listInoutConf, sort, InoutConstant.CONF_TYPE_80, InoutConstant.PROGRESS_WEIGHT_TAG, 1);
        if(null != conf) conf.setSort(sort);
        if (null != conf) conf.setSort(sort);

        view.addObject("cardDto", conf);

@@ -556,6 +556,14 @@
    @Transactional
    public PageResponse<InoutData> inoutNextStep(@RequestBody InoutData data) {
        try {
            IUser user = ContextUtil.getLoginUser();
            if (StringUtils.isEmpty(data.getCompanyId())) {
                data.setCompanyId(user.getCompanyId());
            }
            if (StringUtils.isEmpty(data.getDeptId())) {
                data.setDeptId(ContextUtil.subDeptId(user));
            }

            if (InoutConstant.TYPE_IN.equals(data.getType())) {
                return inoutManager.inNextStep(data);
            } else {
@@ -570,6 +578,31 @@
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "后台异常：" + e.getMessage());
        }
    }

    /**
     * å‡ºå…¥åº“数据保存，登记提交
     *
     * @param data
     * @return
     */
    @RequestMapping("/submit-register")
    @Transactional
    public PageResponse<InoutData> submitRegister(@RequestBody InoutData data) throws Exception {
        IUser user = ContextUtil.getLoginUser();
        if (StringUtils.isEmpty(data.getCompanyId())) {
            data.setCompanyId(user.getCompanyId());
        }
        if (StringUtils.isEmpty(data.getDeptId())) {
            data.setDeptId(ContextUtil.subDeptId(user));
        }

        //如果注册时候没有使用智慧卡，默认使用身份证号作为智慧卡号
        if (StringUtils.isEmpty(data.getIntelCard())) {
            data.setIntelCard(data.getUserId());
        }

        return inoutManager.submitRegisterInout(data);
    }

    /**
@@ -658,6 +691,7 @@

        return null;
    }

    /**
     * æ›´æ–°ç”¨æˆ·é€‰æ‹©åœ°ç£…，根据用户IP保存期选择
     *

 igds-inout/src/main/java/com/ld/igds/inout/manager/InoutManager.java

@@ -44,100 +44,100 @@
@Component
public class InoutManager {

    @Autowired
    private InoutService inoutService;
    @Autowired
    private CoreFileService fileService;
    @Autowired
    private CoreCommonService commonService;
    @Autowired
    private InoutCommonService inoutManagerService;
    @Autowired
    private CheckStandardManager checkStandardManager;
    @Resource
    private InoutDeviceManager inoutDeviceManager;
    @Autowired
    private InoutService inoutService;
    @Autowired
    private CoreFileService fileService;
    @Autowired
    private CoreCommonService commonService;
    @Autowired
    private InoutCommonService inoutManagerService;
    @Autowired
    private CheckStandardManager checkStandardManager;
    @Resource
    private InoutDeviceManager inoutDeviceManager;

    /**
     * å½“前先从当日缓存中获取数据，如果缓存中没有再从数据库获取
     *
     * @param param
     * @return
     */
    public PageResponse<InoutData> inoutQuery(InoutParam param) {
        if (StringUtils.isEmpty(param.getPlateNum())
                && StringUtils.isEmpty(param.getIntelCard())
                && StringUtils.isEmpty(param.getUserId())) {
    /**
     * å½“前先从当日缓存中获取数据，如果缓存中没有再从数据库获取
     *
     * @param param
     * @return
     */
    public PageResponse<InoutData> inoutQuery(InoutParam param) {
        if (StringUtils.isEmpty(param.getPlateNum())
                && StringUtils.isEmpty(param.getIntelCard())
                && StringUtils.isEmpty(param.getUserId())) {

            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "参数不完整，无法获取信息！");
        }
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "参数不完整，无法获取信息！");
        }

        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }
        if (StringUtils.isEmpty(param.getCompanyId())) {
            param.setCompanyId(ContextUtil.getCompanyId());
        }

        InoutData result;
        String progress = param.getProgress();
        try {
            param.setProgress(null);
        InoutData result;
        String progress = param.getProgress();
        try {
            param.setProgress(null);

            result = inoutService.inoutProgressQuery(param);
            if (null == result) {
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                        "未找到流程中的车辆！", null);
            }
            result = inoutService.inoutProgressQuery(param);
            if (null == result) {
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                        "未找到流程中的车辆！", null);
            }

            // å¦‚果没有流程条件说明不需要做判断，直接返回
            if (StringUtils.isEmpty(progress)) {
                return new PageResponse<>(RespCodeEnum.CODE_0000, result);
            }
            // å¦‚果没有流程条件说明不需要做判断，直接返回
            if (StringUtils.isEmpty(progress)) {
                return new PageResponse<>(RespCodeEnum.CODE_0000, result);
            }

            if (!result.getType().equals(param.getType())) {
                if (InoutConstant.TYPE_IN.equals(result.getType())) {
                    return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                            "系统：当前车辆业务为【入库】", result);
                } else {
                    return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                            "系统：当前车辆业务为【出库】", result);
                }
            }
            if (!result.getType().equals(param.getType())) {
                if (InoutConstant.TYPE_IN.equals(result.getType())) {
                    return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                            "系统：当前车辆业务为【入库】", result);
                } else {
                    return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                            "系统：当前车辆业务为【出库】", result);
                }
            }

            // å½“前标签标示既可以是空车称重也可以是满车
            if (progress.equals(InoutConstant.PROGRESS_WEIGHT_TAG)) {
                if (result.getProgress().equals(
                        InoutConstant.PROGRESS_WEIGHT_EMPTY)
                        || result.getProgress().equals(
                                InoutConstant.PROGRESS_WEIGHT_FULL)) {
                    // è¡¨ç¤ºå½“前流程正常
                } else {
                    return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                            "非当前流程，请到"
                                    + InoutConstant.getProcessName(
                                            param.getType(),
                                            result.getProgress()), result);
                }
            } else {
                if (!result.getProgress().equals(progress)) {
                    return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                            "非当前流程，请到"
                                    + InoutConstant.getProcessName(
                                            param.getType(),
                                            result.getProgress()), result);
                }
            }
            // å½“前标签标示既可以是空车称重也可以是满车
            if (progress.equals(InoutConstant.PROGRESS_WEIGHT_TAG)) {
                if (result.getProgress().equals(
                        InoutConstant.PROGRESS_WEIGHT_EMPTY)
                        || result.getProgress().equals(
                        InoutConstant.PROGRESS_WEIGHT_FULL)) {
                    // è¡¨ç¤ºå½“前流程正常
                } else {
                    return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                            "非当前流程，请到"
                                    + InoutConstant.getProcessName(
                                    param.getType(),
                                    result.getProgress()), result);
                }
            } else {
                if (!result.getProgress().equals(progress)) {
                    return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                            "非当前流程，请到"
                                    + InoutConstant.getProcessName(
                                    param.getType(),
                                    result.getProgress()), result);
                }
            }

            // æ ¹æ®å½“前数据判断是否推送
            inoutService.notifyWeb(result);
            // æ ¹æ®å½“前数据判断是否推送
            inoutService.notifyWeb(result);

            //为当前数据添加化验项目和水分和杂质的化验结果,用于出入库增扣重计算
            if (InoutConstant.TYPE_IN.equals(result.getType())) {
                List<CheckItemData> checkItemDataList = inoutService.getCheckCache(result.getCompanyId(), result.getCheckId());
                result.setCheckItems(checkItemDataList);
                if (null != checkItemDataList && checkItemDataList.size() > 0) {
                    for (CheckItemData checkItem : checkItemDataList) {
                        if (StringUtils.isEmpty(checkItem.getValue())) {
                            continue;
                        }
            //为当前数据添加化验项目和水分和杂质的化验结果,用于出入库增扣重计算
            if (InoutConstant.TYPE_IN.equals(result.getType())) {
                List<CheckItemData> checkItemDataList = inoutService.getCheckCache(result.getCompanyId(), result.getCheckId());
                result.setCheckItems(checkItemDataList);
                if (null != checkItemDataList && checkItemDataList.size() > 0) {
                    for (CheckItemData checkItem : checkItemDataList) {
                        if (StringUtils.isEmpty(checkItem.getValue())) {
                            continue;
                        }

//                        if (InoutConstant.CHECK_ITEM_C01.equals(checkItem.getStandardId())) {
//                            result.setWet(Double.valueOf(checkItem.getValue()));
@@ -145,252 +145,245 @@
//                        if (InoutConstant.CHECK_ITEM_C02.equals(checkItem.getStandardId())) {
//                            result.setImpurity(Double.valueOf(checkItem.getValue()));
//                        }
                    }
                }
            }
                    }
                }
            }

            return new PageResponse<>(RespCodeEnum.CODE_0000, result);
            return new PageResponse<>(RespCodeEnum.CODE_0000, result);

        } catch (Exception e) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    e.getMessage());
        }
    }
        } catch (Exception e) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    e.getMessage());
        }
    }

    public PageResponse<InoutData> outNextStep(InoutData data) throws Exception {
        String msg;
        IUser user = ContextUtil.getLoginUser();
        if (StringUtils.isEmpty(data.getCompanyId())) {
            data.setCompanyId(user.getCompanyId());
        }
        if (StringUtils.isEmpty(data.getDeptId())) {
            data.setDeptId(ContextUtil.subDeptId(user));
        }
        if (StringUtils.isEmpty(data.getIntelCard())) {
            data.setIntelCard(data.getUserId());
        }

        String curProgress = data.getProgress();
        List<FileData> files = data.getFiles();

        // æ›´æ–°ä¸‹ä¸€ä¸ªçŠ¶æ€å’ŒåŸºæœ¬ä¿¡æ¯
        InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(
                data.getCompanyId(), data.getDeptId());
        if (null == inoutSysConf
                || StringUtils.isEmpty(inoutSysConf.getProgressIn())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前库区未配置出库流程信息，请联系管理员配置。", data);
        }
        data = updateOutBasicInfo(data, inoutSysConf);

        // å¦‚果当前节点是注册，则需要验证下，是否有为完成的流程在执行中
        if (InoutConstant.PROGRESS_REGISTER.equals(curProgress)) {
            InoutData progressData = this.inoutProgressQuery(data);
            if (null != progressData) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "当前卡片/车牌号有流程未结束。", progressData);
            }
        }

        if(null != data.getPrice() && null != data.getRecordWeight()){
            data.setSettleMoney(NumberUtil.keepPrecision(data.getPrice()*data.getRecordWeight(),2));
    public PageResponse<InoutData> outNextStep(InoutData data) throws Exception {
        String msg;
        IUser user = ContextUtil.getLoginUser();
        if (StringUtils.isEmpty(data.getCompanyId())) {
            data.setCompanyId(user.getCompanyId());
        }
        if (StringUtils.isEmpty(data.getDeptId())) {
            data.setDeptId(ContextUtil.subDeptId(user));
        }
        if (StringUtils.isEmpty(data.getIntelCard())) {
            data.setIntelCard(data.getUserId());
        }

        // æµç¨‹å®Œæˆï¼Œç›´æŽ¥è°ƒç”¨æµç¨‹å®ŒæˆæŽ¥å£
        if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            inoutService.updateData(data);
            // æ‰§è¡Œé™„件信息
            if (null != files) {
                fileService.saveInoutFiles(files, data.getCompanyId(),
                        data.getId(), curProgress);
            }
        String curProgress = data.getProgress();
        List<FileData> files = data.getFiles();

            // é€šçŸ¥ç§°é‡ä¸»æŽ§æµç¨‹ç»“束
            inoutDeviceManager.noticeProgressComplete(data);
        // æ›´æ–°ä¸‹ä¸€ä¸ªçŠ¶æ€å’ŒåŸºæœ¬ä¿¡æ¯
        InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(
                data.getCompanyId(), data.getDeptId());
        if (null == inoutSysConf
                || StringUtils.isEmpty(inoutSysConf.getProgressIn())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前库区未配置出库流程信息，请联系管理员配置。", data);
        }
        data = updateOutBasicInfo(data, inoutSysConf);

            return inoutComplete(data);
        }

        // è°ƒç”¨ä¿å­˜æ–¹æ³•æ‰§è¡Œ
        if (StringUtils.isEmpty(data.getId())) {
            msg = inoutService.insertData(data);
        } else {
            msg = inoutService.updateData(data);
        }

        // æ‰§è¡Œé™„件信息
        if (null != files) {
            fileService.saveInoutFiles(files, data.getCompanyId(),
                    data.getId(), curProgress);
        }

        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg,
                    data);
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
                data);
    }

    public PageResponse<InoutData> inNextStep(InoutData data) throws Exception {
        String msg;
        IUser user = ContextUtil.getLoginUser();
        if (StringUtils.isEmpty(data.getCompanyId())) {
            data.setCompanyId(user.getCompanyId());
        }
        if (StringUtils.isEmpty(data.getDeptId())) {
            data.setDeptId(ContextUtil.subDeptId(user));
        }
        String curProgress = data.getProgress();
        List<FileData> files = data.getFiles();

        if (StringUtils.isEmpty(data.getIntelCard())) {
            data.setIntelCard(data.getUserId());
        }

        // æ›´æ–°ä¸‹ä¸€ä¸ªçŠ¶æ€å’ŒåŸºæœ¬ä¿¡æ¯
        InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());

        if (null == inoutSysConf
                || StringUtils.isEmpty(inoutSysConf.getProgressIn())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前库区未配置入库流程信息，请联系管理员配置。", data);
        }

        data = updateInBasicInfo(data, inoutSysConf);

        // å¦‚果当前节点是注册，则需要验证下，是否有为完成的流程在执行中
        if (InoutConstant.PROGRESS_REGISTER.equals(curProgress)) {
            InoutData progressData = this.inoutProgressQuery(data);
            if (null != progressData) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "当前卡片/车牌号有流程未结束。", progressData);
            }
        }

        if(null != data.getPrice() && null != data.getRecordWeight()){
            data.setSettleMoney(NumberUtil.keepPrecision(data.getPrice()*data.getRecordWeight(),2));
        // å¦‚果当前节点是注册，则需要验证下，是否有为完成的流程在执行中
        if (InoutConstant.PROGRESS_REGISTER.equals(curProgress)) {
            InoutData progressData = this.inoutProgressQuery(data);
            if (null != progressData) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "当前卡片/车牌号有流程未结束。", progressData);
            }
        }

        // æµç¨‹å®Œæˆï¼Œç›´æŽ¥è°ƒç”¨æµç¨‹å®ŒæˆæŽ¥å£
        if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            if (StringUtils.isEmpty(data.getCompanyId())) {
                data.setCompanyId(ContextUtil.getCompanyId());
            }
        if (null != data.getPrice() && null != data.getRecordWeight()) {
            data.setSettleMoney(NumberUtil.keepPrecision(data.getPrice() * data.getRecordWeight(), 2));
        }

            inoutService.updateData(data);
            // æ‰§è¡Œé™„件信息
            if (null != files) {
                fileService.saveInoutFiles(files, data.getCompanyId(),
                        data.getId(), curProgress);
            }
        // æµç¨‹å®Œæˆï¼Œç›´æŽ¥è°ƒç”¨æµç¨‹å®ŒæˆæŽ¥å£
        if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            inoutService.updateData(data);
            // æ‰§è¡Œé™„件信息
            if (null != files) {
                fileService.saveInoutFiles(files, data.getCompanyId(),
                        data.getId(), curProgress);
            }

            // é€šçŸ¥ç§°é‡ä¸»æŽ§æµç¨‹ç»“束
            inoutDeviceManager.noticeProgressComplete(data);
            // é€šçŸ¥ç§°é‡ä¸»æŽ§æµç¨‹ç»“束
            inoutDeviceManager.noticeProgressComplete(data);

            return inoutComplete(data);
        }
            return inoutComplete(data);
        }

        // è°ƒç”¨ä¿å­˜æ–¹æ³•æ‰§è¡Œ
        if (StringUtils.isEmpty(data.getId())) {
            msg = inoutService.insertData(data);
        } else {
            msg = inoutService.updateData(data);
        }
        // è°ƒç”¨ä¿å­˜æ–¹æ³•æ‰§è¡Œ
        if (StringUtils.isEmpty(data.getId())) {
            msg = inoutService.insertData(data);
        } else {
            msg = inoutService.updateData(data);
        }

        // æ‰§è¡Œé™„件信息
        if (null != files) {
            fileService.saveInoutFiles(files, data.getCompanyId(),
                    data.getId(), curProgress);
        }
        // æ‰§è¡Œé™„件信息
        if (null != files) {
            fileService.saveInoutFiles(files, data.getCompanyId(),
                    data.getId(), curProgress);
        }

        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
        }
        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg,
                    data);
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
                data);
    }

        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
                data);
    }
    public PageResponse<InoutData> inNextStep(InoutData data) throws Exception {
        String msg;

    public InoutData inoutProgressQuery(InoutData data) throws Exception {
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setPlateNum(data.getPlateNum());
        param.setIntelCard(data.getIntelCard());
        param.setType(data.getType());
        String curProgress = data.getProgress();
        List<FileData> files = data.getFiles();
        if (StringUtils.isEmpty(data.getIntelCard())) {
            data.setIntelCard(data.getUserId());
        }

        return inoutService.inoutProgressQuery(param);
    }
        // æ›´æ–°ä¸‹ä¸€ä¸ªçŠ¶æ€å’ŒåŸºæœ¬ä¿¡æ¯
        InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(data.getCompanyId(), data.getDeptId());

    @Transactional(rollbackFor = Exception.class)
    public PageResponse<InoutData> updateCheck(InoutData data) throws Exception {
        if (null == inoutSysConf
                || StringUtils.isEmpty(inoutSysConf.getProgressIn())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前库区未配置入库流程信息，请联系管理员配置。", data);
        }

        if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前流程已经结束，不支持修改", data);
        }
        data = updateInBasicInfo(data, inoutSysConf);

        CheckUpdateResult checkResult = this.updateCheckItems(data);
        String tag = checkResult.getMsg();
        // å¦‚果当前节点是注册，则需要验证下，是否有为完成的流程在执行中
        if (InoutConstant.PROGRESS_REGISTER.equals(curProgress)) {
            InoutData progressData = this.inoutProgressQuery(data);
            if (null != progressData) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        "当前卡片/车牌号有流程未结束。", progressData);
            }
        }

        if (null != tag) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "后台执行异常：" + tag, data);
        }
        if (null != data.getPrice() && null != data.getRecordWeight()) {
            data.setSettleMoney(NumberUtil.keepPrecision(data.getPrice() * data.getRecordWeight(), 2));
        }

        // èŽ·å–业务数据信息
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setId(data.getId());
        InoutData progressData = inoutService.inoutProgressQuery(param);
        if (null == progressData) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "没有获取到出入库业务数据信息，更新失败", data);
        }
        if (InoutConstant.PROGRESS_RECORD.equals(progressData.getProgress())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前流程已经结束，不支持修改");
        }
        progressData.setCheckStatus(data.getCheckStatus());
        // æµç¨‹å®Œæˆï¼Œç›´æŽ¥è°ƒç”¨æµç¨‹å®ŒæˆæŽ¥å£
        if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            if (StringUtils.isEmpty(data.getCompanyId())) {
                data.setCompanyId(ContextUtil.getCompanyId());
            }

        // æ›´æ–°ä¸‹ä¸€ä¸ªçŠ¶æ€å’ŒåŸºæœ¬ä¿¡æ¯
        if (InoutConstant.PROGRESS_CHECK.equals(progressData.getProgress())) {
            progressData = updateInBasicInfo(progressData, null);
            // è‹¥åŒ–验结果不合格，判断配置后续流程
            if (InoutConstant.STATUS_UNPASS.equals(progressData
                    .getCheckStatus())) {
                progressData = checkNoPass(progressData);
            }
        }
        progressData.setCheckUser(ContextUtil.getLoginUserCName());
            inoutService.updateData(data);
            // æ‰§è¡Œé™„件信息
            if (null != files) {
                fileService.saveInoutFiles(files, data.getCompanyId(),
                        data.getId(), curProgress);
            }

            // é€šçŸ¥ç§°é‡ä¸»æŽ§æµç¨‹ç»“束
            inoutDeviceManager.noticeProgressComplete(data);

            return inoutComplete(data);
        }

        // è°ƒç”¨ä¿å­˜æ–¹æ³•æ‰§è¡Œ
        if (StringUtils.isEmpty(data.getId())) {
            msg = inoutService.insertData(data);
        } else {
            msg = inoutService.updateData(data);
        }

        // æ‰§è¡Œé™„件信息
        if (null != files) {
            fileService.saveInoutFiles(files, data.getCompanyId(),
                    data.getId(), curProgress);
        }

        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
        }

        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功",
                data);
    }

    public InoutData inoutProgressQuery(InoutData data) throws Exception {
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setPlateNum(data.getPlateNum());
        param.setIntelCard(data.getIntelCard());
        param.setType(data.getType());

        return inoutService.inoutProgressQuery(param);
    }

    @Transactional(rollbackFor = Exception.class)
    public PageResponse<InoutData> updateCheck(InoutData data) throws Exception {

        if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前流程已经结束，不支持修改", data);
        }

        CheckUpdateResult checkResult = this.updateCheckItems(data);
        String tag = checkResult.getMsg();

        if (null != tag) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "后台执行异常：" + tag, data);
        }

        // èŽ·å–业务数据信息
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setId(data.getId());
        InoutData progressData = inoutService.inoutProgressQuery(param);
        if (null == progressData) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "没有获取到出入库业务数据信息，更新失败", data);
        }
        if (InoutConstant.PROGRESS_RECORD.equals(progressData.getProgress())) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "当前流程已经结束，不支持修改");
        }
        progressData.setCheckStatus(data.getCheckStatus());

        // æ›´æ–°ä¸‹ä¸€ä¸ªçŠ¶æ€å’ŒåŸºæœ¬ä¿¡æ¯
        if (InoutConstant.PROGRESS_CHECK.equals(progressData.getProgress())) {
            progressData = updateInBasicInfo(progressData, null);
            // è‹¥åŒ–验结果不合格，判断配置后续流程
            if (InoutConstant.STATUS_UNPASS.equals(progressData
                    .getCheckStatus())) {
                progressData = checkNoPass(progressData);
            }
        }
        progressData.setCheckUser(ContextUtil.getLoginUserCName());
//        if (StringUtils.isNotEmpty(data.getCustomerName())) {
//            progressData.setCustomerId(data.getCustomerId());
//            progressData.setCustomerName(data.getCustomerName());
//        }
        if (StringUtils.isNotEmpty(data.getDepotId())) {
            progressData.setDepotId(data.getDepotId());
        }
        if (StringUtils.isNotEmpty(data.getFoodVariety())) {
            progressData.setFoodVariety(data.getFoodVariety());
        }
        if (StringUtils.isNotEmpty(data.getFoodLevel())) {
            progressData.setFoodLevel(data.getFoodLevel());
        }
        if (StringUtils.isNotEmpty(data.getFoodLocation())) {
            progressData.setFoodLocation(data.getFoodLocation());
        }
        if (StringUtils.isNotEmpty(data.getFoodYear())) {
            progressData.setFoodYear(data.getFoodYear());
        }
        if (null != data.getPrice()) {
            progressData.setPrice(data.getPrice());
        }
        if (StringUtils.isNotEmpty(data.getRemarks())) {
            progressData.setRemarks(data.getRemarks());
        }
        if (StringUtils.isNotEmpty(data.getNoticeId())) {
            progressData.setNoticeId(data.getNoticeId());
        }
        if (StringUtils.isNotEmpty(data.getDepotId())) {
            progressData.setDepotId(data.getDepotId());
        }
        if (StringUtils.isNotEmpty(data.getFoodVariety())) {
            progressData.setFoodVariety(data.getFoodVariety());
        }
        if (StringUtils.isNotEmpty(data.getFoodLevel())) {
            progressData.setFoodLevel(data.getFoodLevel());
        }
        if (StringUtils.isNotEmpty(data.getFoodLocation())) {
            progressData.setFoodLocation(data.getFoodLocation());
        }
        if (StringUtils.isNotEmpty(data.getFoodYear())) {
            progressData.setFoodYear(data.getFoodYear());
        }
        if (null != data.getPrice()) {
            progressData.setPrice(data.getPrice());
        }
        if (StringUtils.isNotEmpty(data.getRemarks())) {
            progressData.setRemarks(data.getRemarks());
        }
        if (StringUtils.isNotEmpty(data.getNoticeId())) {
            progressData.setNoticeId(data.getNoticeId());
        }

//        // å›žå¡«æ°´åˆ†å’Œæ‚è´¨
//        if (checkResult.getWet() > 0) {
@@ -401,662 +394,715 @@
//            progressData.setImpurity(checkResult.getImpurity());
//        }

        String msg = inoutService.updateData(progressData);
        String msg = inoutService.updateData(progressData);

        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
        }
        if (InoutConstant.PROGRESS_RECORD.equals(progressData.getProgress())) {
        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
        }
        if (InoutConstant.PROGRESS_RECORD.equals(progressData.getProgress())) {

            inoutComplete(progressData);
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功");
    }
            inoutComplete(progressData);
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行成功");
    }

    /**
     * åŒ–验结果不通过时校验配置信息
     *
     * @param data
     * @return
     */
    private InoutData checkNoPass(InoutData data) {
        InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(
                data.getCompanyId(), data.getDeptId());
    /**
     * åŒ–验结果不通过时校验配置信息
     *
     * @param data
     * @return
     */
    private InoutData checkNoPass(InoutData data) {
        InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(
                data.getCompanyId(), data.getDeptId());

        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)) {
            // ç¦»åº“收卡
            data.setProgress(InoutConstant.PROGRESS_CARD_BACK);
        }
        return data;
    }
        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)) {
            // ç¦»åº“收卡
            data.setProgress(InoutConstant.PROGRESS_CARD_BACK);
        }
        return data;
    }

    private CheckUpdateResult updateCheckItems(InoutData data) {
        CheckUpdateResult result = new CheckUpdateResult();
        if (null == data.getCheckItems())
            return result;
        try {
            // æ›´æ–°æ£€éªŒé¡¹æ•°æ®
            result = checkStandardManager.updateCheckItems(data.getCheckId(),
                    data.getCompanyId(), data.getCheckItems());
    private CheckUpdateResult updateCheckItems(InoutData data) {
        CheckUpdateResult result = new CheckUpdateResult();
        if (null == data.getCheckItems())
            return result;
        try {
            // æ›´æ–°æ£€éªŒé¡¹æ•°æ®
            result = checkStandardManager.updateCheckItems(data.getCheckId(),
                    data.getCompanyId(), data.getCheckItems());

            // å°†åŒ–验数据存入缓存中
            inoutService.setCheckCache(data);
            // å°†åŒ–验数据存入缓存中
            inoutService.setCheckCache(data);

            return result;
            return result;

        } catch (Exception e) {
            log.error("后台异常：{}", e);
            result.setMsg("执行异常：" + e.getMessage());
        }
        return result;
    }
        } catch (Exception e) {
            log.error("后台异常：{}", e);
            result.setMsg("执行异常：" + e.getMessage());
        }
        return result;
    }

    /**
     * ä»Žç¼“存中获取下一流程
     *
     * @return
     */
    private String getNextProgress(String curProgress, String type,
            InoutSysConf sysConf) {
        String nextProgress = null;
        List<String> list = null;
        if (InoutConstant.TYPE_IN.equals(type)) {
            list = Arrays.asList(sysConf.getProgressIn().split("-"));
        }
        if (InoutConstant.TYPE_OUT.equals(type)) {
            list = Arrays.asList(sysConf.getProgressOut().split("-"));
        }
        if (list != null) {
            for (int i = 0; i < list.size() - 1; i++) {
                if (curProgress.equals(list.get(i))) {
                    nextProgress = list.get(i + 1);
                    break;
                }
            }
        }
        return nextProgress;
    }
    /**
     * ä»Žç¼“存中获取下一流程
     *
     * @return
     */
    private String getNextProgress(String curProgress, String type, InoutSysConf sysConf) {
        String nextProgress = null;
        List<String> list = null;
        if (InoutConstant.TYPE_IN.equals(type)) {
            list = Arrays.asList(sysConf.getProgressIn().split("-"));
        }
        if (InoutConstant.TYPE_OUT.equals(type)) {
            list = Arrays.asList(sysConf.getProgressOut().split("-"));
        }
        if (list != null) {
            for (int i = 0; i < list.size() - 1; i++) {
                if (curProgress.equals(list.get(i))) {
                    nextProgress = list.get(i + 1);
                    break;
                }
            }
        }
        return nextProgress;
    }

    /**
     * æ ¹æ®éœ€è¦ä¿å­˜çš„数据，调整下一个流程状态 ä¸åŒçš„仓库组织流程可能不一样，需要根据实际调整
     *
     * @param data
     * @return
     */
    private InoutData updateInBasicInfo(InoutData data, InoutSysConf sysConf) {
        if (null == sysConf) {
            sysConf = inoutManagerService.getCacheInoutSysConf(
                    data.getCompanyId(), data.getDeptId());
        }
    /**
     * æ ¹æ®éœ€è¦ä¿å­˜çš„数据，调整下一个流程状态 ä¸åŒçš„仓库组织流程可能不一样，需要根据实际调整
     *
     * @param data
     * @return
     */
    private InoutData updateInBasicInfo(InoutData data, InoutSysConf sysConf) {
        if (null == sysConf) {
            sysConf = inoutManagerService.getCacheInoutSysConf(
                    data.getCompanyId(), data.getDeptId());
        }

        if (InoutConstant.PROGRESS_REGISTER.equals(data.getProgress())) {
            data.setRegisterTime(new Date());
            data.setRegisterUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
        if (InoutConstant.PROGRESS_REGISTER.equals(data.getProgress())) {
            data.setRegisterTime(new Date());
            data.setRegisterUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));

            return data;
        }
            return data;
        }

        if (InoutConstant.PROGRESS_WEIGHT_FULL.equals(data.getProgress())) {
            data.setFullWeightTime(new Date());
            data.setFullWeightUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            return data;
        }
        if (InoutConstant.PROGRESS_CHECK.equals(data.getProgress())) {
            data.setCheckUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            return data;
        }
        if (InoutConstant.PROGRESS_WEIGHT_FULL.equals(data.getProgress())) {
            data.setFullWeightTime(new Date());
            data.setFullWeightUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            return data;
        }
        if (InoutConstant.PROGRESS_CHECK.equals(data.getProgress())) {
            data.setCheckUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            return data;
        }

        if (InoutConstant.PROGRESS_WEIGHT_EMPTY.equals(data.getProgress())) {
            data.setEmptyWeightTime(new Date());
            data.setEmptyWeightUser(ContextUtil.getLoginUserCName());
        if (InoutConstant.PROGRESS_WEIGHT_EMPTY.equals(data.getProgress())) {
            data.setEmptyWeightTime(new Date());
            data.setEmptyWeightUser(ContextUtil.getLoginUserCName());

            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));

            if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
                data.setCompleteTime(DateUtils.addMinutes(new Date(), 2));
                data.setCompleteUser(ContextUtil.getLoginUserCName());
            }
            return data;
        }
            if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
                data.setCompleteTime(DateUtils.addMinutes(new Date(), 2));
                data.setCompleteUser(ContextUtil.getLoginUserCName());
            }
            return data;
        }

        if (InoutConstant.PROGRESS_HANDLE.equals(data.getProgress())) {
        if (InoutConstant.PROGRESS_HANDLE.equals(data.getProgress())) {

            // æŸ¥è¯¢ç¼“存中仓库信息，根据仓库id设置值仓人为仓库保管员
            Depot depot = commonService.getCacheDepot(data.getCompanyId(),
                    data.getDepotId());
            data.setHandleUser(depot == null ? "" : depot.getStoreKeeperName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            return data;
        }
            // æŸ¥è¯¢ç¼“存中仓库信息，根据仓库id设置值仓人为仓库保管员
            Depot depot = commonService.getCacheDepot(data.getCompanyId(),
                    data.getDepotId());
            data.setHandleUser(depot == null ? "" : depot.getStoreKeeperName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            return data;
        }

        if (InoutConstant.PROGRESS_CARD_BACK.equals(data.getProgress())) {
            data.setCompleteTime(new Date());
            data.setCompleteUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            return data;
        }
        return data;
    }
        if (InoutConstant.PROGRESS_CARD_BACK.equals(data.getProgress())) {
            data.setCompleteTime(new Date());
            data.setCompleteUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            return data;
        }
        return data;
    }

    /**
     * æ ¹æ®éœ€è¦ä¿å­˜çš„数据，调整下一个流程状态 ä¸åŒçš„仓库组织流程可能不一样，需要根据实际调整
     *
     * @param data
     * @return
     */
    private InoutData updateOutBasicInfo(InoutData data, InoutSysConf sysConf) {
        if (InoutConstant.PROGRESS_REGISTER.equals(data.getProgress())) {
            data.setRegisterTime(new Date());
            data.setRegisterUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
    /**
     * æ ¹æ®éœ€è¦ä¿å­˜çš„数据，调整下一个流程状态 ä¸åŒçš„仓库组织流程可能不一样，需要根据实际调整
     *
     * @param data
     * @return
     */
    private InoutData updateOutBasicInfo(InoutData data, InoutSysConf sysConf) {
        if (InoutConstant.PROGRESS_REGISTER.equals(data.getProgress())) {
            data.setRegisterTime(new Date());
            data.setRegisterUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));

            return data;
        }
        if (InoutConstant.PROGRESS_WEIGHT_EMPTY.equals(data.getProgress())) {
            data.setEmptyWeightTime(new Date());
            data.setEmptyWeightUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            return data;
        }
        if (InoutConstant.PROGRESS_WEIGHT_EMPTY.equals(data.getProgress())) {
            data.setEmptyWeightTime(new Date());
            data.setEmptyWeightUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));

            return data;
        }
            return data;
        }

        if (InoutConstant.PROGRESS_HANDLE.equals(data.getProgress())) {
            // æŸ¥è¯¢ç¼“存中仓库信息，根据仓库id设置值仓人为仓库保管员
            Depot depot = commonService.getCacheDepot(data.getCompanyId(),
                    data.getDepotId());
            data.setHandleUser(depot == null ? "" : depot.getStoreKeeperName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
        if (InoutConstant.PROGRESS_HANDLE.equals(data.getProgress())) {
            // æŸ¥è¯¢ç¼“存中仓库信息，根据仓库id设置值仓人为仓库保管员
            Depot depot = commonService.getCacheDepot(data.getCompanyId(),
                    data.getDepotId());
            data.setHandleUser(depot == null ? "" : depot.getStoreKeeperName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));

            return data;
        }
            return data;
        }

        if (InoutConstant.PROGRESS_WEIGHT_FULL.equals(data.getProgress())) {
            data.setFullWeightTime(new Date());
            data.setFullWeightUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
                data.setCompleteTime(DateUtils.addMinutes(new Date(), 2));
                data.setCompleteUser(ContextUtil.getLoginUserCName());
            }
            return data;
        }
        if (InoutConstant.PROGRESS_WEIGHT_FULL.equals(data.getProgress())) {
            data.setFullWeightTime(new Date());
            data.setFullWeightUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
            if (InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
                data.setCompleteTime(DateUtils.addMinutes(new Date(), 2));
                data.setCompleteUser(ContextUtil.getLoginUserCName());
            }
            return data;
        }

        if (InoutConstant.PROGRESS_CARD_BACK.equals(data.getProgress())) {
            data.setCompleteTime(new Date());
            data.setCompleteUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));
        if (InoutConstant.PROGRESS_CARD_BACK.equals(data.getProgress())) {
            data.setCompleteTime(new Date());
            data.setCompleteUser(ContextUtil.getLoginUserCName());
            data.setProgress(getNextProgress(data.getProgress(),
                    data.getType(), sysConf));

            return data;
        }
            return data;
        }

        return data;
    }
        return data;
    }

    public PageResponse<Page<InoutData>> pageRecordData(InoutParam param) {
    public PageResponse<Page<InoutData>> pageRecordData(InoutParam param) {

        log.debug("分页信息--page={},limit={},cuur={}", param.getPage(),
                param.getLimit(), param.getCurr());
        log.debug("分页信息--page={},limit={},cuur={}", param.getPage(),
                param.getLimit(), param.getCurr());

        Page<InoutData> result = inoutService.pageRecordData(param);
        Page<InoutData> result = inoutService.pageRecordData(param);

        if (null == result.getRecords() || result.getRecords().isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "获取到数据信息为空");
        }
        if (null == result.getRecords() || result.getRecords().isEmpty()) {
            return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                    "获取到数据信息为空");
        }

        return new PageResponse<>(RespCodeEnum.CODE_0000, result);
    }
        return new PageResponse<>(RespCodeEnum.CODE_0000, result);
    }

    /**
     * @param param
     * @return
     */
    public PageResponse<Page<InoutData>> pageCheckData(InoutParam param) {
        // å¦‚果是已化验，则将流程状态置空，如果是未化验，则流程状态不处理，仍是CHECK状态
        if (!"NONE".equals(param.getCheckStatus())) {
            param.setProgress(null);
        }
        // è®¾ç½®åˆ†åº“Id
        String deptId = ContextUtil.subDeptId(null);
        param.setDeptId(deptId);
        return pageRecordData(param);
    }
    /**
     * @param param
     * @return
     */
    public PageResponse<Page<InoutData>> pageCheckData(InoutParam param) {
        // å¦‚果是已化验，则将流程状态置空，如果是未化验，则流程状态不处理，仍是CHECK状态
        if (!"NONE".equals(param.getCheckStatus())) {
            param.setProgress(null);
        }
        // è®¾ç½®åˆ†åº“Id
        String deptId = ContextUtil.subDeptId(null);
        param.setDeptId(deptId);
        return pageRecordData(param);
    }


    public PageResponse<InoutData> inoutComplete(InoutData data) throws Exception {
    public PageResponse<InoutData> inoutComplete(InoutData data) throws Exception {

        if (StringUtils.isEmpty(data.getId())
                || StringUtils.isEmpty(data.getType())) {
        if (StringUtils.isEmpty(data.getId())
                || StringUtils.isEmpty(data.getType())) {

            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到车辆信息。", data);
        }
            return new PageResponse<>(RespCodeEnum.CODE_1007.getCode(),
                    "没有获取到车辆信息。", data);
        }

        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setId(data.getId());
        param.setType(data.getType());
        param.setDeptId(data.getDeptId());
        param.setIntelCard(data.getIntelCard());
        param.setUserId(ContextUtil.getLoginUserCName());
        param.setDepotId(data.getDepotId());
        param.setCompleteTime(data.getCompleteTime());
        if (null == param.getCompleteTime()) {
            param.setCompleteTime(new Date());
        }
        // è®¾ç½®æµç¨‹èŠ‚点直接完成
        param.setProgress(InoutConstant.PROGRESS_RECORD);
        InoutParam param = new InoutParam();
        param.setCompanyId(data.getCompanyId());
        param.setId(data.getId());
        param.setType(data.getType());
        param.setDeptId(data.getDeptId());
        param.setIntelCard(data.getIntelCard());
        param.setUserId(ContextUtil.getLoginUserCName());
        param.setDepotId(data.getDepotId());
        param.setCompleteTime(data.getCompleteTime());
        if (null == param.getCompleteTime()) {
            param.setCompleteTime(new Date());
        }
        // è®¾ç½®æµç¨‹èŠ‚点直接完成
        param.setProgress(InoutConstant.PROGRESS_RECORD);

        if (null == data.getCompleteTime()) {
            data.setCompleteTime(DateUtil.getNewByMinute(new Date(), 2));
        }
        String msg = inoutService.toComplete(param);
        if (null == data.getCompleteTime()) {
            data.setCompleteTime(DateUtil.getNewByMinute(new Date(), 2));
        }
        String msg = inoutService.toComplete(param);

        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
        }
        if (null != msg) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), msg);
        }

        // åº“存调整
        commonService.initInoutDepotStore(data);
        // åº“存调整
        commonService.initInoutDepotStore(data);

        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), null, data);
    }
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), null, data);
    }

    /**
     * æ‰¦æ ·åŒ–验页面获取检验项条目信息
     *
     * @param data
     * @return
     */
    public PageResponse<List<CheckItemData>> getCheckItem(InoutData data) {
    /**
     * æ‰¦æ ·åŒ–验页面获取检验项条目信息
     *
     * @param data
     * @return
     */
    public PageResponse<List<CheckItemData>> getCheckItem(InoutData data) {

        List<CheckItemData> result = checkStandardManager.listCheckItem(
                data.getCheckId(), data.getCompanyId(), data.getDeptId(),
                data.getFoodVariety());
        List<CheckItemData> result = checkStandardManager.listCheckItem(
                data.getCheckId(), data.getCompanyId(), data.getDeptId(),
                data.getFoodVariety());

        return new PageResponse<>(RespCodeEnum.CODE_0000, result);
    }
        return new PageResponse<>(RespCodeEnum.CODE_0000, result);
    }

    /**
     * åˆ é™¤å¹¶å®Œæˆ
     *
     * @param data
     * @return
     */
    public PageResponse<InoutData> deleteInoutData(InoutData data, String msg) {
        try {
            data.setRemarks(msg);
            String result = this.delInoutData(data, false);
            if (null != result) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        result, data);
            }
        } catch (Exception e) {
            log.error("后台异常:{}", e);
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), "后台异常："
                    + e.getMessage(), data);
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行完成",
                data);
    }
    /**
     * åˆ é™¤å¹¶å®Œæˆ
     *
     * @param data
     * @return
     */
    public PageResponse<InoutData> deleteInoutData(InoutData data, String msg) {
        try {
            data.setRemarks(msg);
            String result = this.delInoutData(data, false);
            if (null != result) {
                return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                        result, data);
            }
        } catch (Exception e) {
            log.error("后台异常:{}", e);
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(), "后台异常："
                    + e.getMessage(), data);
        }
        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "执行完成",
                data);
    }

    /**
     * å¡å›žæ”¶é€»è¾‘处理
     *
     * @param data
     * @return
     */
    public PageResponse<InoutData> inoutBack(InoutData data) {
        try {
            // ä»Žç¼“存中获取最新的数据，如果没有则表示流程已经结束。
            InoutParam param = new InoutParam();
            param.setCompanyId(data.getCompanyId());
            param.setId(data.getId());
            InoutData curData = inoutService.inoutProgressQuery(param);
            if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                        "当前卡流程已经完成，无需执行卡回收", data);
            }
            if (InoutConstant.RECORD_STATUS_DEL.equals(curData
                    .getRecordStatus())) {
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                        "当前卡信息已被删除，不能执行卡回收", data);
            }
    /**
     * å¡å›žæ”¶é€»è¾‘处理
     *
     * @param data
     * @return
     */
    public PageResponse<InoutData> inoutBack(InoutData data) {
        try {
            // ä»Žç¼“存中获取最新的数据，如果没有则表示流程已经结束。
            InoutParam param = new InoutParam();
            param.setCompanyId(data.getCompanyId());
            param.setId(data.getId());
            InoutData curData = inoutService.inoutProgressQuery(param);
            if (InoutConstant.PROGRESS_RECORD.equals(curData.getProgress())) {
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                        "当前卡流程已经完成，无需执行卡回收", data);
            }
            if (InoutConstant.RECORD_STATUS_DEL.equals(curData
                    .getRecordStatus())) {
                return new PageResponse<>(RespCodeEnum.CODE_2000.getCode(),
                        "当前卡信息已被删除，不能执行卡回收", data);
            }

            // å¦‚果当前流程状态是卡回收状态，就是完成流程。
            if (InoutConstant.PROGRESS_CARD_BACK.equals(curData.getProgress())) {
                return inoutComplete(curData);
            }
            // å¦‚果当前流程状态是卡回收状态，就是完成流程。
            if (InoutConstant.PROGRESS_CARD_BACK.equals(curData.getProgress())) {
                return inoutComplete(curData);
            }

            // å¦‚果是其他状态，则执行删除逻辑
            return deleteInoutData(curData, "卡回收删除");
            // å¦‚果是其他状态，则执行删除逻辑
            return deleteInoutData(curData, "卡回收删除");

        } catch (Exception e) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "后端执行异常：" + e.getMessage());
        }
    }
        } catch (Exception e) {
            return new PageResponse<>(RespCodeEnum.CODE_1111.getCode(),
                    "后端执行异常：" + e.getMessage());
        }
    }

    /* ============================== è¯¦å•é¡µé¢ç›¸å…³æ“ä½œ ================================= */
    /* ============================== è¯¦å•é¡µé¢ç›¸å…³æ“ä½œ ================================= */

    /**
     * è¡¥å•æ“ä½œ è¡¥å•å› ä¸ºå®Œæˆæ—¶é—´ä¸ç¡®å®šï¼Œæ‰€ä»¥éœ€è¦ç³»ç»Ÿæ ¹æ®å½“前数据进行自动检测，调整原来流水信息和库存
     *
     * @param data
     * @return
     * @throws Exception
     */
    @Transactional
    public String addInoutData(InoutData data) throws Exception {
    /**
     * è¡¥å•æ“ä½œ è¡¥å•å› ä¸ºå®Œæˆæ—¶é—´ä¸ç¡®å®šï¼Œæ‰€ä»¥éœ€è¦ç³»ç»Ÿæ ¹æ®å½“前数据进行自动检测，调整原来流水信息和库存
     *
     * @param data
     * @return
     * @throws Exception
     */
    @Transactional
    public String addInoutData(InoutData data) throws Exception {

        if (data.getSettleWeight() <= 0.0) {
            return "补单数据要求结算重量必须大于0";
        }
        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);
        }
        // è¡¥å•æ•°æ®ç›´æŽ¥åˆ°ç»“果状态
        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));
        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 (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 (InoutConstant.TYPE_IN.equals(data.getType())) {

            if (null == data.getFullWeightTime()) {
                data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -50));
            }
            if (null == data.getHandleEnd()) {
                data.setHandleEnd(DateUtil.getNewByMinute(new Date(), -40));
            }
            if (null == data.getEmptyWeightTime()) {
                data.setEmptyWeightTime(DateUtil.getNewByMinute(new Date(), -10));
            }
            if (null == data.getFullWeightTime()) {
                data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -50));
            }
            if (null == data.getHandleEnd()) {
                data.setHandleEnd(DateUtil.getNewByMinute(new Date(), -40));
            }
            if (null == data.getEmptyWeightTime()) {
                data.setEmptyWeightTime(DateUtil.getNewByMinute(new Date(), -10));
            }

            // å…ˆæ‰§è¡ŒåŒ–验信息保存
            CheckUpdateResult checkResult = checkStandardManager.updateCheckItems(data.getCheckId(), data.getCompanyId(),data.getCheckItems());
            if (null != checkResult) {
            // å…ˆæ‰§è¡ŒåŒ–验信息保存
            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.getHandleEnd()) {
                data.setHandleEnd(DateUtil.getNewByMinute(new Date(), -40));
            }
            if (null == data.getFullWeightTime()) {
                data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -10));
            }
        }
            }
        } else {
            if (null == data.getEmptyWeightTime()) {
                data.setEmptyWeightTime(DateUtil.getNewByMinute(new Date(), -50));
            }
            if (null == data.getHandleEnd()) {
                data.setHandleEnd(DateUtil.getNewByMinute(new Date(), -40));
            }
            if (null == data.getFullWeightTime()) {
                data.setFullWeightTime(DateUtil.getNewByMinute(new Date(), -10));
            }
        }

        // æ·»åŠ è¡¥å•æ•°æ®
        String msg = inoutService.insertData(data);
        // æ·»åŠ è¡¥å•æ•°æ®
        String msg = inoutService.insertData(data);

        // åˆå§‹åŒ–验证出入库库存
        commonService.initInoutDepotStore(data);
        return msg;
    }
        // åˆå§‹åŒ–验证出入库库存
        commonService.initInoutDepotStore(data);
        return msg;
    }

    /**
     * ä¿®æ”¹æ“ä½œ ä¿®æ”¹é€»è¾‘说明：修改数据需要获取原数据库中的数据进行对比。
     *
     * @param data
     * @return
     * @throws Exception
     */
    @javax.transaction.Transactional(rollbackOn = Exception.class)
    public String updateInoutData(InoutData data) throws Exception {
    /**
     * ä¿®æ”¹æ“ä½œ ä¿®æ”¹é€»è¾‘说明：修改数据需要获取原数据库中的数据进行对比。
     *
     * @param data
     * @return
     * @throws Exception
     */
    @javax.transaction.Transactional(rollbackOn = Exception.class)
    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.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);
        }
        // å¦‚果流程未结束，只更新数据
        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);
        // å¦‚果是已经完成的数据，先获取到修改直接的数据根据数据进行对比
        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 (null == record) {
            return "当前修改数据已经不存在！";
        }

        // é¿å…æ•°æ®åº“中的数据已经被其他人修改
        if (InoutConstant.RECORD_STATUS_DEL.equals(record.getRecordStatus())) {
            return "系统：已经删除的数据不支持修改！";
        }
        if (InoutConstant.RECORD_STATUS_ERROR.equals(record.getRecordStatus())) {
            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 (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);
        // this.autoCheckByUpdate(data, record);
        return null;
    }
        // æ›´æ–°æ•°æ®
        inoutService.updateData(data);
        // this.autoCheckByUpdate(data, record);
        return null;
    }

    /**
     * åˆ é™¤æ“ä½œ åˆ é™¤æ•°æ®ä¸ºè½¯åˆ é™¤ï¼Œåˆ é™¤æ•°æ®åŽéœ€è¦æ ¹æ®åˆ é™¤æƒ…况联动库存等信息
     *
     * @param data
     * @param selected
     *            æ˜¯å¦å·²ç»æŸ¥è¯¢è¿‡æ•°æ®
     * @return
     * @throws Exception
     */
    @Transactional
    public String delInoutData(InoutData data, boolean selected)
            throws Exception {
    /**
     * åˆ é™¤æ“ä½œ åˆ é™¤æ•°æ®ä¸ºè½¯åˆ é™¤ï¼Œåˆ é™¤æ•°æ®åŽéœ€è¦æ ¹æ®åˆ é™¤æƒ…况联动库存等信息
     *
     * @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 (!selected) {
            data = inoutService.inoutQueryById(param);

            if (InoutConstant.RECORD_STATUS_DEL.equals(data.getRecordStatus())) {
                return "已经删除的数据，不支持重复删除！";
            }
            if (InoutConstant.RECORD_STATUS_ERROR
                    .equals(data.getRecordStatus())) {
                return "当前数据已经被标记为异常，不支持删除！";
            }
        }
            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);
        // æ‰§è¡Œåˆ é™¤
        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;
    }
        // å¦‚果流程未结束，直接删除，不牵扯到联动调整
        if (!InoutConstant.PROGRESS_RECORD.equals(data.getProgress())) {
            return null;
        }
        return null;
    }

    /**
     * å¼‚常终止操作 è®¾ç½®å¼‚常 ä¸ºäº†é¿å…é¡µé¢æ•°æ®ç¼“存，需要重新获取最新数据判断
     *
     * @param data
     * @return
     * @throws Exception
     */
    @Transactional
    public String errorInoutData(InoutData data){
    /**
     * å¼‚常终止操作 è®¾ç½®å¼‚常 ä¸ºäº†é¿å…é¡µé¢æ•°æ®ç¼“存，需要重新获取最新数据判断
     *
     * @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);
        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 "流程结束的数据不支持异常处理！";
        }
        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);
    }
        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 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 "当前车辆流程状态已经变化，请刷新页面重新操作！";
        }
        // ä»Žæ–°æŸ¥è¯¢æ•°æ®
        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 (null == data.getCompleteTime()) {
            return "请填写完成时间！！";
        }
        if (StringUtils.isEmpty(data.getDepotId())) {
            return "请填写仓库信息！";
        }
//        if (StringUtils.isEmpty(data.getCustomerId())) {
//            return "请填写往来单位信息！";
//        }
        if (StringUtils.isEmpty(data.getFoodYear())) {
            return "请填写粮食年份信息！";
        }
        if (StringUtils.isEmpty(data.getFoodVariety())) {
            return "请填写粮食品种信息！";
        }
        if (StringUtils.isEmpty(data.getFoodYear())) {
            return "请填写粮食年份信息！";
        }
        if (StringUtils.isEmpty(data.getFoodVariety())) {
            return "请填写粮食品种信息！";
        }

        if (data.getSettleWeight() <= 0) {
            return "请填写结算净重信息！";
        }
        if (data.getSettleWeight() <= 0) {
            return "请填写结算净重信息！";
        }

        String msg = inoutService.quickComplete(data);
        String msg = inoutService.quickComplete(data);

        if (null == msg) {
            data.setProgress(InoutConstant.PROGRESS_RECORD);
            commonService.initInoutDepotStore(data);
        }
        return msg;
    }
        if (null == msg) {
            data.setProgress(InoutConstant.PROGRESS_RECORD);
            commonService.initInoutDepotStore(data);
        }
        return msg;
    }

    public void initLpr(InoutConf conf) {
        inoutDeviceManager.initLpr(conf);
    }
	
    /**
     * èŽ·å–出入库设备配置信息
     *
     * @param companyId
     * @param deptId
     * @return
     */
    public List<InoutConf> getListInoutConf(String companyId, String deptId) {
        return inoutManagerService.getCacheInoutConf(companyId, deptId);
    }
    public void initLpr(InoutConf conf) {
        inoutDeviceManager.initLpr(conf);
    }

    /**
     * æ“ä½œé“闸设备
     * @param param
     * @return
     */
    public PageResponse<List<CheckItemData>> gateCtrl(InoutGateDto param){
    /**
     * èŽ·å–出入库设备配置信息
     *
     * @param companyId
     * @param deptId
     * @return
     */
    public List<InoutConf> getListInoutConf(String companyId, String deptId) {
        return inoutManagerService.getCacheInoutConf(companyId, deptId);
    }

        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "", null);
    }
    /**
     * æ“ä½œé“闸设备
     *
     * @param param
     * @return
     */
    public PageResponse<List<CheckItemData>> gateCtrl(InoutGateDto param) {

        return new PageResponse<>(RespCodeEnum.CODE_0000.getCode(), "", null);
    }

    /**
     * å‡ºå…¥åº“注册数据提交，入库登记和出入库登记使用同一个方法
     *
     * @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 = inoutManagerService.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.setRegisterTime(new Date());
        data.setRegisterUser(ContextUtil.getLoginUserCName());
        data.setProgress(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);
    }

}

 igds-inout/src/main/java/com/ld/igds/inout/mapper/InoutRecordMapper.java

@@ -97,9 +97,7 @@
     * æ›´æ–°å‡ºå…¥åº“流水实时库存
     *
     * @param param
     * @return

    int updateCuStorage(@Param("param") InoutParam param);
     * @return int updateCuStorage(@Param("param") InoutParam param);
     */

    /**
@@ -120,24 +118,6 @@
    void toComplete(@Param("param") InoutParam param);

    /**
     * èŽ·å–入库完成量
     *
     * @param param
     * @return

    CommonData getInComplete(@Param("param") NoticeParam param);
     */

    /**
     * èŽ·å–出库完成量
     *
     * @param param
     * @return

    CommonData getOutComplete(@Param("param") NoticeParam param);
     */

    /**
     * èŽ·å–流程未完成的流水数据
     *
     * @param page
@@ -154,4 +134,12 @@
     * @return CommonData.numValue1
     */
    CommonData sumRecordWeight(@Param("param") InoutParam param);

    /**
     * æ ¹æ®è½¦ç‰Œå·å’Œå¡å·æŸ¥è¯¢æ˜¯å¦æœ‰æœªå®Œæˆçš„流程信息
     *
     * @param param
     * @return
     */
    int checkExist(@Param("param") InoutParam param);
}

 igds-inout/src/main/java/com/ld/igds/inout/service/InoutService.java

@@ -56,7 +56,7 @@
     * @return è¿”回异常信息，正常返回null
     * @throws Exception
     */
    String insertData(InoutData data) throws Exception;
    String insertData(InoutData data);

    /**
     * æ›´æ–°æ•°æ®
@@ -236,4 +236,12 @@
     * @return
     */
    double sumRecordWeight(InoutParam param);

    /**
     * æ•°æ®åº“根据车牌号和智慧卡号是否已经存在
     *
     * @param param
     * @return
     */
    int checkExist(InoutParam param);
}

 igds-inout/src/main/java/com/ld/igds/inout/service/impl/InoutServiceImpl.java

@@ -118,59 +118,44 @@

    @Override
    public String insertData(InoutData data) {
        try {
            data.setUpdateTime(new Date());

        if (StringUtils.isEmpty(data.getCompanyId())) {
            data.setCompanyId(ContextUtil.getCompanyId());
        }
            if (null == data.getDeptId()) {
                data.setDeptId(ContextUtil.subDeptId(null));
            }

        // èŽ·å–当前仓库的实际库存
        if (StringUtils.isNotEmpty(data.getDepotId())) {
            if (null == data.getFoodYear() || null == data.getFoodType()) {
                Depot depot = commonService.getCacheDepot(data.getCompanyId(), data.getDepotId());
                if (null == data.getFoodYear()) {
                    data.setFoodYear(depot.getFoodYear());
                }
                if (null == data.getFoodType()) {
                    data.setFoodType(depot.getFoodType());
            String id = this.createId(data.getRegisterTime(), data.getCompanyId());
            if (StringUtils.isEmpty(data.getId())) {
                if (InoutConstant.TYPE_IN.equals(data.getType())) {
                    data.setId("R_" + id);
                } else if (InoutConstant.TYPE_OUT.equals(data.getType())) {
                    data.setId("C_" + id);
                } else if (Constant.LOSS_OVER_OVER.equals(data.getType())) {
                    data.setId("R_" + id);
                } else if (Constant.LOSS_OVER_LOSS.equals(data.getType())) {
                    data.setId("C_" + id);
                } else {
                    data.setId("M_" + id);
                }
            }
        }

        if (null == data.getRegisterTime()) {
            data.setRegisterTime(new Date());
        }

        String id = this.createId(data.getRegisterTime(), data.getCompanyId());

        if (StringUtils.isEmpty(data.getId())) {
            if (InoutConstant.TYPE_IN.equals(data.getType())) {
                data.setId("R_" + id);
            } else if (InoutConstant.TYPE_OUT.equals(data.getType())) {
                data.setId("C_" + id);
            } else if (Constant.LOSS_OVER_OVER.equals(data.getType())) {
                data.setId("R_" + id);
            } else if (Constant.LOSS_OVER_LOSS.equals(data.getType())) {
                data.setId("C_" + id);
            } else {
                data.setId("M_" + id);
            if (StringUtils.isEmpty(data.getCheckId())) {
                data.setCheckId(id);
            }
        }
        if (StringUtils.isEmpty(data.getCheckId())) {
            data.setCheckId(id);
        }
        if (null == data.getDeptId()) {
            data.setDeptId(ContextUtil.subDeptId(null));
        }
        if (null == data.getUserName()) {
            data.setUserName("");
        }

        inoutMapper.insertData(data);
            if (null == data.getUserName()) {
                data.setUserName("");
            }

        // å¦‚果不是手动补录的数据，添加到缓存中
        if (!InoutConstant.RECORD_STATUS_ADD.equals(data.getRecordStatus())) {
            inoutMapper.insertData(data);

            this.addInoutCache(data);

        } catch (Exception e) {
            log.error("------------出入库执行保存出错---{}", e);
            return "后台异常：" + e.getMessage();
        }

        return null;
    }

@@ -234,9 +219,9 @@

        List<InoutData> records = inoutMapper.pageRecordData(page, param);
        //判断入库重量是否为空，为空则赋值结算重量
        if(records != null){
        if (records != null) {
            for (InoutData record : records) {
                if(record.getRecordWeight() == null || record.getRecordWeight() == 0.0){
                if (record.getRecordWeight() == null || record.getRecordWeight() == 0.0) {
                    record.setRecordWeight(record.getSettleWeight());
                }
            }
@@ -677,6 +662,11 @@
        return result.getNumValue1();
    }

    @Override
    public int checkExist(InoutParam param) {
        return inoutMapper.checkExist(param);
    }

    /**
     * æœªå®Œæˆæµç¨‹å­˜å…¥ç¼“å­˜
     *

 igds-inout/src/main/java/com/ld/igds/m/service/HInoutConfService.java

@@ -4,9 +4,11 @@
import com.ld.igds.models.InoutConf;
import com.ld.igds.models.InoutSysConf;
import com.ld.igds.util.ContextUtil;

import org.apache.commons.lang3.StringUtils;
import org.hibernate.Session;
import org.springframework.stereotype.Component;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -64,42 +66,30 @@
        return null;
    }

    public List<InoutSysConf> getSysConfData(Map<String, Object> param) {

        Map<String, Object> args = new HashMap<String, Object>();
        String hql = " from " + InoutSysConf.class.getName()
                + " where companyId=:companyId and deptId=:deptId";

        args.put("companyId", ContextUtil.getCompanyId());
        String deptId = "";
        if (null != param) {
            deptId = (String) param.get("deptId");
        }

        if (StringUtils.isEmpty(deptId)) {
            deptId = ContextUtil.subDeptId(null);
        }

        args.put("deptId", deptId);

        return this.query(hql, args);
    }

    public String saveSysConfData(InoutSysConf data) {
        Session session = this.getSessionFactory().openSession();
        try {
            if (StringUtils.isEmpty(data.getDeptId())) {
                data.setDeptId(ContextUtil.subDeptId(null));
                data.setCompanyId(ContextUtil.getCompanyId());
                session.save(data);
            } else {
                session.update(data);
            }

            session.saveOrUpdate(data);
        } finally {
            session.flush();
            session.close();
        }
        return null;
    }

    public InoutSysConf getSysConfData(String companyId, String deptId) {
		
        String hql = " from " + InoutSysConf.class.getName()
                + " where companyId=:companyId and deptId=:deptId";

        Map<String, Object> args = new HashMap<String, Object>();
        args.put("companyId", companyId);
        args.put("deptId", deptId);
		
        List<InoutSysConf> list = this.query(hql, args);
		
        if(null == list || list.isEmpty()) return new InoutSysConf();

        return list.get(0);
    }
}

 igds-inout/src/main/java/com/ld/igds/m/view/InoutNoticePR.java

@@ -188,14 +188,14 @@

        InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(companyId, deptId);

        if(Constant.YN_Y.equals(inoutSysConf.getNoticeTagIn())){
            List<InoutNoticeIn> noticeInList = inoutManagerService.getUnComNoticeIn(companyId);
        List<InoutNoticeIn> noticeInList = inoutManagerService.getUnComNoticeIn(companyId);

            if (noticeInList != null && noticeInList.size() > 0) {
                inoutManagerService.updateSumNoticeIn(inoutSysConf.getDeptId(), noticeInList);
                return "success";
            }
        if (noticeInList != null && noticeInList.size() > 0) {
            inoutManagerService.updateSumNoticeIn(inoutSysConf.getDeptId(), noticeInList);
            return "success";
        }
		
		
        return "fail";
    }

@@ -269,13 +269,11 @@

        InoutSysConf inoutSysConf = inoutManagerService.getCacheInoutSysConf(companyId, deptId);

        if(Constant.YN_Y.equals(inoutSysConf.getNoticeTagOut())){
            List<InoutNoticeOut> noticeOutList = inoutManagerService.getUnComNoticeOut(companyId);
        List<InoutNoticeOut> noticeOutList = inoutManagerService.getUnComNoticeOut(companyId);

            if (noticeOutList != null && noticeOutList.size() > 0) {
                inoutManagerService.updateSumNoticeOut(inoutSysConf.getDeptId(), noticeOutList);
                return "success";
            }
        if (noticeOutList != null && noticeOutList.size() > 0) {
            inoutManagerService.updateSumNoticeOut(inoutSysConf.getDeptId(), noticeOutList);
            return "success";
        }
        return "fail";
    }

 igds-inout/src/main/java/com/ld/igds/m/view/InoutSysConf.view.xml

@@ -8,7 +8,6 @@
      <PropertyDef name="companyId">
        <Property></Property>
        <Property name="label">组织编码</Property>
        <Property name="required">true</Property>
      </PropertyDef>
      <PropertyDef name="deptId">
        <Property></Property>
@@ -22,26 +21,6 @@
      <PropertyDef name="progressOut">
        <Property></Property>
        <Property name="label">出库流程</Property>
        <Property name="required">true</Property>
      </PropertyDef>
      <PropertyDef name="noticeTagIn">
        <Property></Property>
        <Property name="label">入库通知单启用</Property>
        <Property name="mapping">
          <Property name="mapValues">${dorado.getDataProvider(&quot;inoutSysConfPR#triggerYesOrNo&quot;).getResult()}</Property>
          <Property name="keyProperty">code</Property>
          <Property name="valueProperty">name</Property>
        </Property>
        <Property name="required">true</Property>
      </PropertyDef>
      <PropertyDef name="noticeTagOut">
        <Property></Property>
        <Property name="label">出库通知单启用</Property>
        <Property name="mapping">
          <Property name="mapValues">${dorado.getDataProvider(&quot;inoutSysConfPR#triggerYesOrNo&quot;).getResult()}</Property>
          <Property name="keyProperty">code</Property>
          <Property name="valueProperty">name</Property>
        </Property>
        <Property name="required">true</Property>
      </PropertyDef>
      <PropertyDef name="noticeWx">
@@ -81,19 +60,10 @@
    </DataType>
  </Model>
  <View layout="padding:5;regionPadding:5">
    <ClientEvent name="onReady">var deptId = &quot;${request.getParameter('deptId')}&quot;;&#xD;
&#xD;
//查询&#xD;
query = function(){&#xD;
    var data = {deptId:deptId};&#xD;
    view.get(&quot;#dsMain&quot;).set(&quot;parameter&quot;,data).flushAsync();&#xD;
};&#xD;
query();</ClientEvent>
    <Property name="packages">font-awesome,css-common</Property>
    <DataSet id="dsMain">
      <Property name="dataProvider">inoutSysConfPR#getSysConfData</Property>
      <Property name="dataType">dtMain</Property>
      <Property name="loadMode">manual</Property>
    </DataSet>
    <Container layout="regionPadding:10" layoutConstraint="top">
      <Property name="exClassName">bg-color</Property>
@@ -132,20 +102,6 @@
          <Property name="name">progressOut</Property>
          <Property name="property">progressOut</Property>
          <Property name="editorType">TextArea</Property>
          <Editor/>
        </AutoFormElement>
        <Label layoutConstraint="colSpan:3"/>
        <Control/>
        <AutoFormElement layoutConstraint="colSpan:3">
          <Property name="name">noticeTagIn</Property>
          <Property name="property">noticeTagIn</Property>
          <Editor/>
        </AutoFormElement>
        <Label layoutConstraint="colSpan:3"/>
        <Control/>
        <AutoFormElement layoutConstraint="colSpan:3">
          <Property name="name">noticeTagOut</Property>
          <Property name="property">noticeTagOut</Property>
          <Editor/>
        </AutoFormElement>
        <Label layoutConstraint="colSpan:3"/>

 igds-inout/src/main/java/com/ld/igds/m/view/InoutSysConfPR.java

@@ -1,5 +1,6 @@
package com.ld.igds.m.view;

import com.bstek.bdf2.core.business.IUser;
import com.bstek.dorado.annotation.DataProvider;
import com.bstek.dorado.annotation.DataResolver;
import com.ld.igds.constant.Constant;
@@ -8,6 +9,7 @@
import com.ld.igds.m.service.InoutCommonService;
import com.ld.igds.models.DicTrigger;
import com.ld.igds.models.InoutSysConf;
import com.ld.igds.util.ContextUtil;

import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -15,7 +17,6 @@

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * å‡ºå…¥åº“流程配置
@@ -68,16 +69,9 @@
     * @throws Exception
     */
    @DataProvider
    public InoutSysConf getSysConfData(Map<String, Object> param) {
        List<InoutSysConf> list = inoutConfService.getSysConfData(param);
        InoutSysConf inoutSysConf;
        if (list.isEmpty()) {
            inoutSysConf = new InoutSysConf();
            saveSysConfData(inoutSysConf);
        } else {
            inoutSysConf = list.get(0);
        }
        return inoutSysConf;
    public InoutSysConf getSysConfData() {
        IUser u = ContextUtil.getLoginUser();
        return  inoutConfService.getSysConfData(u.getCompanyId(),ContextUtil.subDeptId(u));
    }

    /**
@@ -88,13 +82,21 @@
     */
    @DataResolver
    public String saveSysConfData(InoutSysConf data) {
    	
        if(null == data.getDeptId()){
            data.setDeptId(ContextUtil.subDeptId(null));
        }
        if(null == data.getCompanyId()){
            data.setCompanyId(ContextUtil.getCompanyId());
        }
		
        inoutConfService.saveSysConfData(data);


        
        
        InoutSysConf newData = new InoutSysConf();
       BeanUtils.copyProperties(data, newData);
        BeanUtils.copyProperties(data, newData);
        inoutManagerService.flushInoutSysConfCache(newData);

        
        return null;
    }


 igds-inout/src/main/java/com/ld/igds/timer/InoutScheduled.java

@@ -3,7 +3,6 @@
import com.bstek.bdf2.core.model.DefaultCompany;
import com.bstek.dorado.annotation.Expose;
import com.ld.igds.common.CoreCommonService;
import com.ld.igds.constant.Constant;
import com.ld.igds.constant.DepotStatus;
import com.ld.igds.inout.InoutConstant;
import com.ld.igds.inout.dto.InoutData;
@@ -208,16 +207,12 @@
        for (InoutSysConf inoutSysConf : inoutSysConfList) {

            //  åˆ¤æ–­å…¥åº“通知单是否启用
            if (Constant.YN_Y.equals(inoutSysConf.getNoticeTagIn())) {
                //更新入库通知单完成量
                inoutCommonService.updateSumNoticeIn(inoutSysConf.getDeptId(), noticeInList);
            }
             //更新入库通知单完成量
            inoutCommonService.updateSumNoticeIn(inoutSysConf.getDeptId(), noticeInList);

            //  åˆ¤æ–­å‡ºåº“通知单是否启用
            if (Constant.YN_Y.equals(inoutSysConf.getNoticeTagOut())) {
                //更新出库通知单完成量
                inoutCommonService.updateSumNoticeOut(inoutSysConf.getDeptId(), noticeOutList);
            }
            //更新出库通知单完成量
            inoutCommonService.updateSumNoticeOut(inoutSysConf.getDeptId(), noticeOutList);
        }
    }


 igds-inout/src/main/resources/mapper/InoutRecordMapper.xml

@@ -14,37 +14,35 @@
        TYPE_ as type,
        PROGRESS_ as progress,
        RECORD_STATUS_ as recordStatus,
        CUSTOMER_NAME_ as customerName,
        INTEL_CARD_ as intelCard,
        REGISTER_TIME_ as registerTime,
        REGISTER_USER_ as registerUser,
        USER_NAME_ as userName,
        USER_CONTACT_ as userContact,
        USER_ID_ as userId,
        USER_BIRTHDAY_ as userBirthday,
        USER_SEX_ as userSex,
        USER_NATION_ as userNation,
        USER_ID_ as userId,
        USER_CONTACT_ as userContact,
        USER_ADDRESS_ as userAddress,
        CUR_STORAGE_ as curStorage,
        INTEL_CARD_ as intelCard,
        PLATE_NUM_ as plateNum,
        TRANS_TYPE_ as transType,
        SPEC_TYPE_ as specType,
        CUSTOMER_ID_ as customerId,
        CUSTOMER_NAME_ as customerName,
        FOOD_VARIETY_ as foodVariety,
        FOOD_TYPE_ as foodType,
        FOOD_LEVEL_ as foodLevel,
        FOOD_LOCATION_ID_ as foodLocationId,
        FOOD_LOCATION_ as foodLocation,
        FOOD_YEAR_ as foodYear,
        CHECK_STATUS_ as checkStatus,
        CHECK_USER_ as checkUser,
        CHECK_TIME_ as checkTime,
        SAMPLE_USER_ as sampleUser,
        SAMPLE_TIME_ as sampleTime,
        SAMPLE_TYPE_ as sampleType,
        CHECK_ID_ as checkId,
        IMPURITY_ as impurity,
        WET_ as wet,
        DE_IMPURITY_ as deImpurity,
        DE_WET_ as deWet,
        DE_HANDLE_ as deHandle,
        DE_OTHER_ as deOther,
        DE_SUM_ as deSum,
        DE_CHECK_ as deCheck,
        ADD_CHECK_ as addCheck,
        jjlx as jjlx,
        FULL_WEIGHT_ as fullWeight,
        FULL_WEIGHT_TIME_ as fullWeightTime,
        FULL_WEIGHT_USER_ as fullWeightUser,
@@ -52,16 +50,22 @@
        EMPTY_WEIGHT_TIME_ as emptyWeightTime,
        EMPTY_WEIGHT_USER_ as emptyWeightUser,
        NET_WEIGHT_ as netWeight,
        DE_HANDLE_ as deHandle,
        DE_PACKAGE_ as dePackage,
        DE_OTHER_ as deOther,
        DE_OTHER_INTO_ as deOtherInfo,
        SETTLE_WEIGHT_ as settleWeight,
        RECORD_WEIGHT_ as recordWeight,
        PRICE_ as price,
        SETTLE_MONEY_ as settleMoney,
        HANDLE_START_ as handleStart,
        HANDLE_END_ as handleEnd,
        SETTLE_ID_ as settleId,
        HANDLE_USER_ as handleUser,
        COMPLETE_TIME_ as completeTime,
        COMPLETE_USER_ as completeUser,
        REMARKS_ as remarks
        REMARKS_ as remarks,
        bzw as bzw,
        dbz as dbz,
        bzbjs as bzbjs
    </sql>

    <!-- æ ¹æ®æ¡ä»¶æŸ¥è¯¢ï¼Œæ•°æ®å¿…须是流程中的数据 -->
@@ -262,7 +266,7 @@
    </update>


    <!-- ç™»è®°æ—¶å€™æ’入当前库存的值curStorage ä¹‹åŽä¸åšæ›´æ”¹ -->
    <!-- æ–°å¢žæ•°æ® -->
    <insert id="insertData" parameterType="com.ld.igds.inout.dto.InoutData">
        insert into
        D_INOUT_RECORD(
@@ -274,37 +278,35 @@
        TYPE_,
        PROGRESS_,
        RECORD_STATUS_,
        CUSTOMER_NAME_,
        INTEL_CARD_,
        REGISTER_TIME_,
        REGISTER_USER_,
        USER_NAME_,
        USER_CONTACT_,
        USER_ID_,
        USER_BIRTHDAY_,
        USER_SEX_,
        USER_NATION_,
        USER_ID_,
        USER_CONTACT_,
        USER_ADDRESS_,
        CUR_STORAGE_,
        INTEL_CARD_,
        PLATE_NUM_,
        TRANS_TYPE_,
        SPEC_TYPE_,
        CUSTOMER_ID_,
        CUSTOMER_NAME_,
        FOOD_VARIETY_,
        FOOD_TYPE_,
        FOOD_LEVEL_,
        FOOD_LOCATION_ID_,
        FOOD_LOCATION_,
        FOOD_YEAR_,
        CHECK_STATUS_,
        CHECK_USER_,
        CHECK_TIME_,
        SAMPLE_USER_,
        SAMPLE_TIME_,
        SAMPLE_TYPE_,
        CHECK_ID_,
        IMPURITY_,
        WET_,
        DE_IMPURITY_,
        DE_WET_,
        DE_HANDLE_,
        DE_OTHER_,
        DE_SUM_,
        DE_CHECK_,
        ADD_CHECK_,
        jjlx,
        FULL_WEIGHT_,
        FULL_WEIGHT_TIME_,
        FULL_WEIGHT_USER_,
@@ -312,17 +314,23 @@
        EMPTY_WEIGHT_TIME_,
        EMPTY_WEIGHT_USER_,
        NET_WEIGHT_,
        DE_HANDLE_,
        DE_PACKAGE_,
        DE_OTHER_,
        DE_OTHER_INTO_,
        SETTLE_WEIGHT_,
        RECORD_WEIGHT_,
        PRICE_,
        SETTLE_MONEY_,
        HANDLE_START_,
        HANDLE_END_,
        SETTLE_ID_,
        HANDLE_USER_,
        COMPLETE_TIME_,
        COMPLETE_USER_,
        REMARKS_,
        SETTLE_TAG_
        bzw,
        dbz,
        bzbjs,
        UPDATE_TIME_
        )
        values
        (
@@ -334,37 +342,35 @@
        #{data.type},
        #{data.progress},
        #{data.recordStatus},
        #{data.customerName},
        #{data.intelCard},
        #{data.registerTime},
        #{data.registerUser},
        #{data.userName},
        #{data.userContact},
        #{data.userId},
        #{data.userBirthday},
        #{data.userSex},
        #{data.userNation},
        #{data.userId},
        #{data.userContact},
        #{data.userAddress},
        #{data.curStorage},
        #{data.intelCard},
        #{data.plateNum},
        #{data.transType},
        #{data.specType},
        #{data.customerId},
        #{data.customerName},
        #{data.foodVariety},
        #{data.foodType},
        #{data.foodLevel},
        #{data.foodLocationId},
        #{data.foodLocation},
        #{data.foodYear},
        #{data.checkStatus},
        #{data.checkUser},
        #{data.checkTime},
        #{data.sampleUser},
        #{data.sampleTime},
        #{data.sampleType},
        #{data.checkId},
        #{data.impurity},
        #{data.wet},
        #{data.deImpurity},
        #{data.deWet},
        #{data.deHandle},
        #{data.deOther},
        #{data.deSum},
        #{data.deCheck},
        #{data.addCheck},
        #{data.jjlx},
        #{data.fullWeight},
        #{data.fullWeightTime},
        #{data.fullWeightUser},
@@ -372,17 +378,23 @@
        #{data.emptyWeightTime},
        #{data.emptyWeightUser},
        #{data.netWeight},
        #{data.deHandle},
        #{data.dePackage},
        #{data.deOther},
        #{data.deOtherInfo},
        #{data.settleWeight},
        #{data.recordWeight},
        #{data.price},
        #{data.settleMoney},
        #{data.handleStart},
        #{data.handleEnd},
        #{data.settleId},
        #{data.handleUser},
        #{data.completeTime},
        #{data.completeUser},
        #{data.remarks},
        #{data.settleTag}
        #{data.bzw},
        #{data.dbz},
        #{data.bzbjs},
        #{data.updateTime}
        )
    </insert>

@@ -520,4 +532,20 @@
        </if>
    </select>

    <!--根据车牌和卡号验证是否有重复信息-->
    <select id="checkExist" parameterType="com.ld.igds.inout.dto.InoutParam">
        select count(1)
        from
        D_INOUT_RECORD
        WHERE COMPANY_ID_ = #{param.companyId}
        AND TYPE_ = #{param.type}
        AND (PLATE_NUM_ = #{param.plateNum} or INTEL_CARD_ = #{param.intelCard})
        AND PROGRESS_ != 'RECORD'
        AND RECORD_STATUS_ != 'ERROR'
        AND RECORD_STATUS_ != 'DEL'
        <if test="param.start != null">
            AND REGISTER_TIME_  <![CDATA[ > ]]> #{param.start}
        </if>
    </select>

</mapper>

 igds-web/src/main/resources/static/admin/inout/in-register.js

@@ -78,9 +78,7 @@
            layer.close(index);
            var data = json.content;
            if (data === "not found") {
                layer.alert("没有获取到身份证信息！", {
                    offset: ['300px', '300px']
                });
                alertError("没有获取到身份证信息！");
                return;
            }
            // ä¸´æ—¶èµ‹å€¼
@@ -100,16 +98,15 @@
            }
        },
        error: function () {
            layer.alert("身份证读取失败！", {
                offset: ['300px', '300px']
            });
            layer.close(index);
            alertError("身份证读取失败！");
        }
    });
}

//使用插件读取智慧卡号
function flushICCard() {
    var index = layer.load();
    $("#intelCard").val(null);
    $.ajax({
        type: "GET",
@@ -120,23 +117,25 @@
        jsonp: "callback",
        jsonpCallback: "jsonpCallback",
        success: function (json) {
            layer.close(index);
            //console.log(json);
            var data = json.no;
            //console.log(data);
            if (data === "not found") {
                layer.alert("请重新读卡！", {offset: ['300px', '300px']});
                alertError("请重新读卡！");
            } else {
                $("#intelCard").val(data);
            }
        },
        error: function () {
            layer.alert("IC卡读取出错！", {offset: ['300px', '300px']});
            layer.close(index);
            alertError("IC卡读取出错！");
        }
    });
}

//读取车牌号
function flushPlateNum() {
function getPlateNum() {
    var index = layer.load();
    $.ajax({
        type: "POST",
@@ -146,26 +145,16 @@
        data: JSON.stringify(lprDto),
        success: function (result) {
            if (result.code != "0000") {
                layer.alert(result.msg, {
                    offset: ['300px', '300px']
                });
                alertError(result.msg);
            } else {
                if (result.data.errorMsg) {
                    layer.alert(result.data.errorMsg, {
                        offset: ['300px', '300px']
                    });
                } else {
                    $("#plateNum").val(result.data.plateNum);
                    $("#plateNum2").val(result.data.plateNum);
                }
                $("#plateNum").val(result.data.plateNum);
                $("#plateNum2").val(result.data.plateNum);
            }
            layer.close(index);
        },
        error: function () {
            layer.close(index);
            layer.alert("车牌识别失败！", {
                offset: ['300px', '300px']
            });
            alertError("车牌识别失败！");
        }
    });
}
@@ -183,15 +172,15 @@
function submit() {
    var data = form.val("form-data");
    if (!data.userName) {
        notify("承运人信息不能为空", null);
        alertError("承运人信息不能为空");
        return;
    }
    if (!data.plateNum) {
        notify("车牌号不能为空", null);
        alertError("车牌号不能为空");
        return;
    }
    if (!data.userId) {
        notify("身份证号不能为空", null);
        alertError("身份证号不能为空");
        return;
    }

@@ -214,14 +203,12 @@
        data: JSON.stringify(snapData),
        success: function (result) {
            if (result.code != "0000") {
                layer.alert(result.msg);
                alertError(result.msg);
                submitData(data);
            } else {
                snapData = result.data;

                $("#pz-img").addClass("kccz-r-img-red");
                $("#pz-text").text("已拍照");

                submitData(data);
            }
        },
@@ -235,66 +222,28 @@
//执行保存数据
function submitData(data) {
    var index = layer.load();

    var files = [{
        fileName: snapData.fileName1
    }];
    data.files = files;

    $.ajax({
        type: "POST",
        url: "../../basic/inout/inout-next-step",
        url: "../../basic/inout/submit-register",
        dataType: "json",
        contentType: "application/json;charset=UTF-8",
        data: JSON.stringify(data),
        success: function (result) {
            layer.close(index);
            if (result.code != "0000") {
                notify(result.msg, result.data);
                notifyProgress(result.msg, result.data);
            } else {
                notify("数据提交成功", result.data);
                // é‡ç½®é¡µé¢
                notifyProgress("数据提交成功", result.data);
                resetForm();
            }
        },
        error: function () {
            layer.close(index);
            layer.alert("提交失败，请重新尝试！！");
            alertError("提交失败，请重新尝试！！");
        }
    });
}

/**
 * å¼¹å‡ºæé†’框
 * @param msg æé†’信息
 * @param data æ•°æ®ä¿¡æ¯ï¼Œå¯èƒ½ä¸ºç©º
 */
function notify(msg, data) {
    if (data) {
        //赋值
        $("#resultMsg").text(msg);
        $("#resultUserName").text(data.userName);
        $("#resultPlateNum").text(data.plateNum);
        if ("IN" == data.type) {
            $("#resultType").text("入库-" + INOUT_PROGRESS_MSG(data.progress));
        } else {
            $("#resultType").text("出库-" + INOUT_PROGRESS_MSG(data.progress));
        }
        $("#resultIntelCard").text(data.intelCard);

        layer.open({
            type: 1,
            offset: ['150px', '200px'],
            area: '450px;',
            shade: 0.8,
            id: 'dialog_notify_info',
            btn: ['确定'],
            content: $('#dialog-from-notify'),
            yes: function (index) {
                layer.closeAll();
            }
        });
    } else {
        layer.alert(msg, {offset: ['300px', '300px']});
    }
}

 igds-web/src/main/resources/static/admin/inout/in-register20220529.js

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,359 @@
//当前节点 å…¥åº“登记
var layer;
var form;
var snapData;//登记照片

$(function () {
    layui.use(['layer', 'laydate', 'form', 'util'], function () {
        var util = layui.util;
        var laydate = layui.laydate;
        layer = layui.layer;
        form = layui.form;
        laydate.render({
            elem: '#userBirthday'
        });

        // å³ä¸‹è§’添加固定信息
        util.fixbar({
            bar1: true,
            css: {
                right: 10,
                bottom: 20
            },
            bgcolor: '#53adce',
            click: function (type) {
                if (type === 'bar1') {
                    layer.closeAll();
                    layer.open({
                        type: 2,
                        title: false,
                        shadeClose: true,
                        shade: 0.3,
                        closeBtn: 2,
                        offset: ['50px','50px'],
                        area: ['1000px', '640px'],
                        content: '../../basic/inout/inout-progress?type=' + type + "&t=" + Math.random()
                    });
                }
            }
        });
    });

    //显示入库流程
    showProgress();

    var rightH = $(".rkbk-left-wrap").height();
    $(".rkbk-right-wrap").height(rightH);

    $(window).resize(function () {
        var rightH = $(".rkbk-left-wrap").height();
        $(".rkbk-right-wrap").height(rightH);
    });

    // åˆå§‹åŒ–WebSocket
    initInoutWS(deptId, bizType, progress, userId);
});

window.onload = function () {
    // åŠ è½½è§†é¢‘
    initVideo(lprDto, null, null);
};

//控制流程环节显示
function showProgress() {
    if (!inoutProgress) {
        return;
    }
    if (inoutProgress.indexOf("REGISTER") == -1) {
        $("#progress-register").css("display", "none");
    }
    if (inoutProgress.indexOf("CHECK") == -1) {
        $("#progress-check").css("display", "none");
    }
    if (inoutProgress.indexOf("WEIGHT_FULL") == -1) {
        $("#progress-fullWeight").css("display", "none");
    }
    if (inoutProgress.indexOf("HANDLE") == -1) {
        $("#progress-hand").css("display", "none");
    }
    if (inoutProgress.indexOf("WEIGHT_EMPTY") == -1) {
        $("#progress-emptyWeight").css("display", "none");
    }
    if (inoutProgress.indexOf("CARD_BACK") == -1) {
        $("#progress-cardBack").css("display", "none");
    }
}

// socket信息返回處理
function socketOnMessage(packet) {

}

//使用插件读取身份证
function flushIdCard() {
    var index = layer.load();
    $.ajax({
        type: "GET",
        async: true,
        url: "http://127.0.0.1:9111/IDCARD",
        data: {},
        dataType: "jsonp",
        jsonp: "callback",
        jsonpCallback: "jsonpCallback",
        success: function (json) {
            layer.close(index);
            var data = json.content;
            if (data === "not found") {
                layer.alert("没有获取到身份证信息！", {
                    offset: ['300px', '300px']
                });
                return;
            }
            // ä¸´æ—¶èµ‹å€¼
            $("#userName").val(data.cnName);
            $("#userSex").val(data.sex);
            $("#userNation").val(data.nation);
            $("#userAddress").val(data.address);
            //$("#id_img_pers").attr("src",data.Image);
            var time = data.birthdate;
            if (time.length == 8) {
                time = time.substring(0, 4) + "-" + time.substring(4, 6) + "-" + time.substring(6);
            }
            $("#userBirthday").val(time);
            $("#userId").val(data.idNum);
            if (data.Image) {
                $("#id_img_pers").attr("src", data.Image);
            }
        },
        error: function () {
            layer.alert("身份证读取失败！", {
                offset: ['300px', '300px']
            });
            layer.close(index);
        }
    });
}

//使用插件读取智慧卡号
function flushICCard() {
    $("#intelCard").val(null);
    $.ajax({
        type: "GET",
        async: true,
        url: "http://127.0.0.1:9111/ICCARD",
        data: {},
        dataType: "jsonp",
        jsonp: "callback",
        jsonpCallback: "jsonpCallback",
        success: function (json) {
            //console.log(json);
            var data = json.no;
            //console.log(data);
            if (data === "not found") {
                layer.alert("请重新读卡！", {offset: ['300px', '300px']});
            } else {
                $("#intelCard").val(data);
            }
        },
        error: function () {
            layer.alert("IC卡读取出错！", {offset: ['300px', '300px']});
        }
    });
}

//读取车牌号
function flushPlateNum() {
    var param = JSON.stringify(lprDto);
    var index = layer.load();
    $.ajax({
        type: "POST",
        url: "../../inout/api/flush-lpr",
        dataType: "json",
        contentType: "application/json;charset=UTF-8",
        data: param,
        success: function (result) {
            if (result.code != "0000") {
                layer.alert(result.msg, {
                    offset: ['300px', '300px']
                });
            } else {
                if (result.data.errorMsg) {
                    layer.alert(result.data.errorMsg, {
                        offset: ['300px', '300px']
                    });
                } else {
                    $("#plateNum").val(result.data.plateNum);
                }
            }
            layer.close(index);
        },
        error: function () {
            layer.close(index);
            layer.alert("车牌识别失败！", {
                offset: ['300px', '300px']
            });
        }
    });
}

//重置车牌识别信息
function resetPlateNum() {
    var index = layer.load();
    var param = JSON.stringify(lprDto);
    $.ajax({
        type: "POST",
        url: "../../inout/api/reset-lpr",
        dataType: "json",
        contentType: "application/json;charset=UTF-8",
        data: param,
        success: function (result) {
            if (result.code != "0000") {
                layer.alert(result.msg, {
                    offset: ['300px', '300px']
                });
            } else {
                layer.alert("重置成功，请重新获取车牌信息", {
                    offset: ['300px', '300px']
                });
            }
            layer.close(index);
        },
        error: function () {
            layer.close(index);
            layer.alert("重置执行失败", {
                offset: ['300px', '300px']
            });
        }
    });
}

// è¡¨å•æ¸…空
function resetForm() {
    $("#form-data")[0].reset();
    form.render();
    // èº«ä»½è¯é‡ç½®
    $("#id_img_pers").attr("src", "../../static/images/rkbk-photo_03.png");
    $("#pz-img").removeClass("kccz-r-img-red");
    $("#pz-text").text("自动抓拍");
}

// å½“前完成
function submit() {
    var data = form.val("form-data");
    if (!data.userName) {
        notify("承运人信息不能为空", null);
        return;
    }
    if (!data.plateNum) {
        notify("车牌号不能为空", null);
        return;
    }
    if (!data.intelCard && !data.userId) {
        notify("智慧卡号与身份证号不能同时为空", null);
        return;
    }

    //系统抓拍
    layer.msg("系统自动抓拍记录……");
    snapData = {
        companyId: companyId,
        deptId: deptId,
        progress: progress,
        bizType: bizType,
        plateNum: data.plateNum,
        id1: (null != lprDto) ? lprDto.id : null
    };

    $.ajax({
        sync: false,
        type: "POST",
        url: "../../inout/api/snap-img",
        dataType: "json",
        contentType: "application/json;charset=UTF-8",
        data: JSON.stringify(snapData),
        success: function (result) {
            if (result.code != "0000") {
                layer.alert(result.msg);
                submitData(data);
            } else {
                snapData = result.data;

                $("#pz-img").addClass("kccz-r-img-red");
                $("#pz-text").text("已拍照");

                submitData(data);
            }
        },
        error: function () {
            layer.msg("后台调用截图失败，请重新尝试！！");
            submitData(data);
        }
    });
}

//执行保存数据
function submitData(data) {
    var index = layer.load();

    var files = [{
        fileName: snapData.fileName1
    }];
    data.files = files;

    $.ajax({
        type: "POST",
        url: "../../basic/inout/inout-next-step",
        dataType: "json",
        contentType: "application/json;charset=UTF-8",
        data: JSON.stringify(data),
        success: function (result) {
            layer.close(index);
            if (result.code != "0000") {
                notify(result.msg, result.data);
            } else {
                notify("数据提交成功", result.data);
                // é‡ç½®é¡µé¢
                resetForm();
            }
        },
        error: function () {
            layer.close(index);
            layer.alert("提交失败，请重新尝试！！");
        }
    });
}

/**
 * å¼¹å‡ºæé†’框
 * @param msg æé†’信息
 * @param data æ•°æ®ä¿¡æ¯ï¼Œå¯èƒ½ä¸ºç©º
 */
function notify(msg, data) {
    if (data) {
        //赋值
        $("#resultMsg").text(msg);
        $("#resultUserName").text(data.userName);
        $("#resultPlateNum").text(data.plateNum);
        if ("IN" == data.type) {
            $("#resultType").text("入库-" + INOUT_PROGRESS_MSG(data.progress));
        } else {
            $("#resultType").text("出库-" + INOUT_PROGRESS_MSG(data.progress));
        }
        $("#resultIntelCard").text(data.intelCard);

        layer.open({
            type: 1,
            offset: ['150px', '200px'],
            area: '450px;',
            shade: 0.8,
            id: 'dialog_notify_info',
            btn: ['确定'],
            content: $('#dialog-from-notify'),
            yes: function (index) {
                layer.closeAll();
            }
        });
    } else {
        layer.alert(msg, {offset: ['300px', '300px']});
    }
}

 igds-web/src/main/resources/static/admin/inout/inout-common.js

@@ -21,4 +21,46 @@
    if (inoutProgress.indexOf("CARD_BACK") == -1) {
        $("#progress-cardBack").css("display", "none");
    }
}
}

//错误提醒
function alertError(msg) {
    layer.alert(msg, {
        icon: 5,
        offset: ['300px', '300px']
    });
}

/**
 * å¼¹å‡ºæé†’框
 * @param msg æé†’信息
 * @param data æ•°æ®ä¿¡æ¯ï¼Œå¯èƒ½ä¸ºç©º
 */
function notifyProgress(msg, data) {
    if (data) {
        //赋值
        $("#resultMsg").text(msg);
        $("#resultUserName").text(data.userName);
        $("#resultPlateNum").text(data.plateNum);
        if ("IN" == data.type) {
            $("#resultType").text("入库-" + INOUT_PROGRESS_MSG(data.progress));
        } else {
            $("#resultType").text("出库-" + INOUT_PROGRESS_MSG(data.progress));
        }
        $("#resultIntelCard").text(data.intelCard);
        layer.open({
            type: 1,
            offset: ['150px', '200px'],
            area: '450px;',
            shade: 0.8,
            id: 'dialog_notify_info',
            btn: ['确定'],
            content: $('#dialog-from-notify'),
            yes: function (index) {
                layer.closeAll();
            }
        });
    } else {
        layer.alert(msg, {offset: ['300px', '300px']});
    }
}

 igds-web/src/main/resources/templates/admin/inout/in-register.html

@@ -262,7 +262,7 @@
                                <div class="layui-form-item">
                                    <input type="button" value="读车牌"
                                        class="rkbk-r-btn fr layui-btn layui-btn-normal"
                                        onclick="flushPlateNum()" /> <label
                                        onclick="getPlateNum()" /> <label
                                        class="layui-form-label color-red">运输车牌：</label>
                                    <div class="layui-input-block">
                                        <input type="text" name="plateNum" id="plateNum"