udi-wms-java/src/main/java/com/glxp/api/controller/inout/IoOrderController.java

package com.glxp.api.controller.inout;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageInfo;
import com.glxp.api.annotation.AuthRuleAnnotation;
import com.glxp.api.annotation.CusRedissonAnnotation;
import com.glxp.api.annotation.Log;
import com.glxp.api.annotation.RepeatSubmit;
import com.glxp.api.common.enums.ResultEnum;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.*;
import com.glxp.api.controller.BaseController;
import com.glxp.api.dao.basic.UdiProductDao;
import com.glxp.api.entity.auth.AuthAdmin;
import com.glxp.api.entity.auth.InvBusUserEntity;
import com.glxp.api.entity.auth.InvWarehouseEntity;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.EntrustReceEntity;
import com.glxp.api.entity.basic.UdiProductEntity;
import com.glxp.api.entity.inout.*;
import com.glxp.api.http.sync.SpGetHttpClient;
import com.glxp.api.req.auth.FilterInvBusUserRequest;
import com.glxp.api.req.basic.BasicDataRequest;
import com.glxp.api.req.basic.BasicEntrustRecRequest;
import com.glxp.api.req.inout.*;
import com.glxp.api.req.system.DeleteRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.inout.*;
import com.glxp.api.service.auth.CustomerService;
import com.glxp.api.service.auth.InvBusUserService;
import com.glxp.api.service.auth.InvWarehouseService;
import com.glxp.api.service.basic.BasicCorpService;
import com.glxp.api.service.basic.EntrustReceService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inout.*;
import com.glxp.api.service.inout.impl.IoCodeService;
import com.glxp.api.service.inout.impl.IoOrderInvoiceService;
import com.glxp.api.service.inv.InvPreProductDetailService;
import com.glxp.api.service.inv.InvPreinProductDetailService;
import com.glxp.api.service.inv.impl.InvProductDetailService;
import com.glxp.api.service.system.SystemParamConfigService;
import com.glxp.api.util.*;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.util.*;
import java.util.stream.Collectors;

import static com.glxp.api.constant.ConstantStatus.ORDER_STATUS_CHECK_PROCESS;

/**
 * UDI出入库单据-单据明细模块
 * data: 2023/11/18
 */

@Slf4j
@RestController
public class IoOrderController extends BaseController {

    @Resource
    private IoOrderService orderService;
    @Resource
    private IBasicBussinessTypeService basicBussinessTypeService;
    @Resource
    private IoCodeTempService codeTempService;
    @Resource
    private IoCheckInoutService checkInoutService;
    @Resource
    IoOrderDetailBizService orderDetailBizService;
    @Resource
    IoOrderDetailCodeService orderDetailCodeService;
    @Resource
    IoAddInoutService ioAddInoutService;
    @Resource
    IoCheckInoutService ioCheckInoutService;
    @Resource
    IoOrderInvoiceService orderInvoiceService;
    @Resource
    CustomerService customerService;
    @Resource
    private SystemParamConfigService systemParamConfigService;
    @Resource
    InvPreProductDetailService invPreProductDetailService;
    @Resource
    InvPreinProductDetailService invPreinProductDetailService;
    @Resource
    InvProductDetailService invProductDetailService;

    @Resource
    IoOrderInvoiceService ioOrderInvoiceService;

    @Resource
    UdiProductDao udiProductDao;

    @Resource
    IoSplitFifoCodeService fifoCodeService;

    /**
     * 查询单据列表
     *
     * @param filterOrderRequest
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/inout/order/filter")
    public BaseResponse filterOrder(FilterOrderRequest filterOrderRequest) {
        if (StrUtil.isNotBlank(filterOrderRequest.getStatusType())) {
            orderService.setFilterStatus(filterOrderRequest);
        }
        if (StrUtil.isNotBlank(filterOrderRequest.getVueType())) {
            orderService.setActions(filterOrderRequest);
            //要是不存在要查询的单据类型就直接放回空
            if (CollUtil.isEmpty(filterOrderRequest.getActions())) {
                PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(new ArrayList<>());
                return ResultVOUtils.page(pageInfo);
            }
        }
        if (StrUtil.isNotEmpty(filterOrderRequest.getSupInoivceSearch())) {
            orderService.setInvoiceFiltes(filterOrderRequest);
        }
        if (filterOrderRequest.getSourceLocalType() != null) {
            if (filterOrderRequest.getSourceLocalType() == 1) {
                filterOrderRequest.setSourceTypes(Arrays.asList(1, 2, 3, 4, 5));
            } else {
                filterOrderRequest.setSourceTypes(Arrays.asList(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17));
            }
        }

        String customerId = getCustomerId();
        if (!customerId.equals("110")) {
            filterOrderRequest.setFromCorp(customerId);
        }
        //拿到当前单据
        List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
        //根据单据查询 发票号
        for (IoOrderResponse ioOrderResponse : list) {
            FilterOrderDetailCodeRequest filterOrderDetailCodeRequest = new FilterOrderDetailCodeRequest();
            filterOrderDetailCodeRequest.setOrderIdFk(ioOrderResponse.getBillNo());
            List<IoOrderInvoiceEntity> orderInvoiceEntities = ioOrderInvoiceService.findByBillNo(filterOrderDetailCodeRequest.getOrderIdFk());
            String invoiceCodes = orderInvoiceEntities.stream()
                    .map(IoOrderInvoiceEntity::getInvoiceEncode)
                    .collect(Collectors.joining(","));
            ioOrderResponse.setInvoiceCodes(invoiceCodes);
        }

        PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
        return ResultVOUtils.page(pageInfo);
    }

    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/inout/order/filterList")
    public BaseResponse filterOrderList(FilterOrderRequest filterOrderRequest) {


        if (StrUtil.isNotBlank(filterOrderRequest.getStatusType())) {
            orderService.setFilterStatus(filterOrderRequest);
        }
        if (StrUtil.isNotBlank(filterOrderRequest.getVueType())) {
            //要是不存在要查询的单据类型就直接放回空
            if (orderService.setActions(filterOrderRequest) == null) {
                PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(new ArrayList<>());
                return ResultVOUtils.page(pageInfo);
            }

        }

        if (StrUtil.isNotEmpty(filterOrderRequest.getSupInoivceSearch())) {
            orderService.setInvoiceFiltes(filterOrderRequest);
        }

        if (filterOrderRequest.getSourceLocalType() != null) {
            if (filterOrderRequest.getSourceLocalType() == 1) {
                filterOrderRequest.setSourceTypes(Arrays.asList(1, 2, 3, 4, 5));
            } else {
                filterOrderRequest.setSourceTypes(Arrays.asList(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17));
            }
        }

        String customerId = getCustomerId();
        if (!customerId.equals("110")) {
            filterOrderRequest.setFromCorp(customerId);
        }
        List<IoOrderResponse> list = orderService.getfilterOrderList(filterOrderRequest);

        for (IoOrderResponse ioOrderResponse : list) {
            if (ioOrderResponse.getCheckStatus() == null) {
                ioOrderResponse.setCheckStatus(0 + "");
            }
            ioOrderResponse = orderInvoiceService.findRegStausByBillNo(ioOrderResponse);
        }
        PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
        return ResultVOUtils.page(pageInfo);
    }


    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/inout/preInorder/filter")
    public BaseResponse filterPreInorder(FilterOrderRequest filterOrderRequest) {
        filterOrderRequest.setVueType(Constant.ORDER_ACTION_SUP_PREIN);
        orderService.setActions(filterOrderRequest);
        List<IoOrderResponse> list = new ArrayList<>();
        if (CollUtil.isEmpty(filterOrderRequest.getActions()))
            return ResultVOUtils.page(new PageInfo<>(list));
        list = orderService.filterList(filterOrderRequest);
        PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
        return ResultVOUtils.page(pageInfo);
    }

    @GetMapping("/udiwms/inout/order/filterInvoice")
    public BaseResponse filterInvoice(FilterOrderRequest filterOrderRequest) {
        filterOrderRequest.setDealStatuses(Arrays.asList(2, 3));
        filterOrderRequest.setStatuses(Arrays.asList(7, 5, 10));
        String customerId = getCustomerId();
        if (!customerId.equals("110")) {
            filterOrderRequest.setFromCorp(customerId);
        }
        List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
        PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
        return ResultVOUtils.page(pageInfo);
    }

    //切换单据清空单据信息
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/delmitBiz")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse delmitBiz(@RequestBody AddOrderRequest addOrderRequest) {

        IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
//        BaseResponse tempResponse = checkSubmitEnable(orderEntity);
//        if (tempResponse != null)
//            return tempResponse;
        //校验单据是否已完成
        int b = orderDetailBizService.deleteByOrderId(addOrderRequest.getBillNo());

        return null;
    }

    //新增业务-立即提交
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/submitBiz")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse submitBiz(@RequestBody AddOrderRequest addOrderRequest) {

        IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
        BaseResponse tempResponse = checkSubmitEnable(orderEntity);
        if (tempResponse != null)
            return tempResponse;
        //校验单据是否已完成
        List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(addOrderRequest.getBillNo());

        if (CollUtil.isEmpty(orderDetailBizEntities)) {
            return ResultVOUtils.error(500, "请先录入产品！");
        }

        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
        String vailKey = "";
        for (IoOrderDetailBizEntity orderDetailBizEntity : orderDetailBizEntities) {

            if (orderDetailBizEntity.getBindRlFk() == null) {
                return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "该产品未指定唯一耗材编码！");
            }
            if (StrUtil.isEmpty(orderDetailBizEntity.getSupId())) {
                return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "该产品未指定供应商！");
            }
            if (IntUtil.value(orderDetailBizEntity.getCount()) == 0) {
                return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "产品数量不能为0！");
            }

            if (bussinessTypeEntity.getCheckWebNew() == 1 || bussinessTypeEntity.getCheckWebNew() == 3) {
                if (StrUtil.isEmpty(orderDetailBizEntity.getBatchNo())
                        && StrUtil.isEmpty(orderDetailBizEntity.getProductDate())
                        && StrUtil.isEmpty(orderDetailBizEntity.getExpireDate())) {
                    return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "三期不能全为空！");
                }
            }
        }
        ioAddInoutService.dealBusProcess(orderEntity, bussinessTypeEntity);
        return ResultVOUtils.success("提交成功！");
    }

    @Resource
    IoCheckInvService checkInvService;

    //新增扫码单据-立即提交
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/submitCodes")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    @CusRedissonAnnotation(cacheName = RedissonCacheKey.SUBMIT_ORDER, key = {"#addOrderRequest.billNo"}, timeOutMsg = "系统正在处理，请勿重复提交")
    public BaseResponse submitCodes(@RequestBody AddOrderRequest addOrderRequest) {

        //校验单据是否已完成
        List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(addOrderRequest.getBillNo());

        if (CollUtil.isEmpty(orderDetailCodeEntities)) {
            return ResultVOUtils.error(500, "单据未扫码或扫码校验无法通过,提交失败,请检查后重新提交！");
        }
        IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
        orderEntity.setRemark(addOrderRequest.getRemark());
        BaseResponse tempResponse = checkSubmitEnable(orderEntity);
        if (tempResponse != null)
            return tempResponse;
        BaseResponse baseResponse = ioAddInoutService.dealProcess(orderEntity);
        if (baseResponse != null)
            return baseResponse;
        //不需要手动校验，则走正常单据校验处理流程
        if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
            ioCheckInoutService.check(orderEntity.getBillNo());
        }
        return ResultVOUtils.success("提交成功,等待处理！");
    }


    //新增业务单据，新增扫码单据，等待校验-草稿保存
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/saveOrderWeb")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse saveOrderWeb(@RequestBody AddOrderRequest addOrderRequest) {
        System.out.println(addOrderRequest.toString());
        IoOrderEntity orderEntity = new IoOrderEntity();
        if (StrUtil.isEmpty(addOrderRequest.getAction()))
            return ResultVOUtils.error(500, "单据类型不能为空");

        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(addOrderRequest.getAction());
        //要是特殊往来信息没有就创建
        if (addOrderRequest.getOrderType() != null) {
            orderEntity.setOrderType(addOrderRequest.getOrderType());
        }
        orderEntity.setFromCorp(ioAddInoutService.updateCorp(bussinessTypeEntity, addOrderRequest.getFromCorp(), addOrderRequest.getSickerAdNum()));
        orderEntity.setAction(addOrderRequest.getAction());
        orderEntity.setMainAction(bussinessTypeEntity.getMainAction());
        orderEntity.setRemark(addOrderRequest.getRemark());
        orderEntity.setFromInvCode(addOrderRequest.getFromInvCode());
        orderEntity.setDeptCode(addOrderRequest.getDeptCode());
        orderEntity.setBillNo(addOrderRequest.getBillNo());
        orderEntity.setInvCode(addOrderRequest.getInvCode());
        if (addOrderRequest.getProductType() == null) {
            //器械单据
            orderEntity.setProductType(1);
        } else {
            //药品单据
            orderEntity.setProductType(addOrderRequest.getProductType());
        }
        orderService.updateByBillNo(orderEntity);
        IoCodeTempEntity warehouseEntity = new IoCodeTempEntity();
        warehouseEntity.setOrderId(orderEntity.getBillNo());
        warehouseEntity.setAction(orderEntity.getAction());
        warehouseEntity.setMainAction(orderEntity.getMainAction());
        warehouseEntity.setDeptCode(orderEntity.getDeptCode());
        warehouseEntity.setInvCode(orderEntity.getInvCode());
        codeTempService.updateByOrderId(warehouseEntity);
        return ResultVOUtils.success("保存成功！");
    }

    //待配货(有三期，无三期）-立即提交
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/submitOrderWeb")
    @CusRedissonAnnotation(cacheName = RedissonCacheKey.SUBMIT_ORDER, key = {"#addOrderRequest.billNo"}, timeOutMsg = "系统正在处理，请勿重复提交")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse submitOrderWeb(@RequestBody AddOrderRequest addOrderRequest) {

        IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
        //补充备注
        if (addOrderRequest.getRemark() != null) {
            orderEntity.setRemark(addOrderRequest.getRemark());
        }
        BaseResponse tempResponse = checkSubmitEnable(orderEntity);
        if (tempResponse != null)
            return tempResponse;

        //校验单据是否已完成
        List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(addOrderRequest.getBillNo());
        List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(addOrderRequest.getBillNo());
        List<IoCodeTempEntity> codeTempEntities = codeTempService.findByOrderId(orderEntity.getBillNo());

        if (CollUtil.isEmpty(orderDetailCodeEntities)) {
            return ResultVOUtils.error(500, "提交失败，单据还未扫码或和扫码校验存在异常！");
        }

        //单据提交后再次校验库存是否足够
        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
        BaseResponse baseResponse = ioAddInoutService.checkInv(bussinessTypeEntity, orderDetailBizEntities, orderEntity, codeTempEntities);
        if (baseResponse != null)
            return baseResponse;


        //上货校验追溯码是否重复
        if (bussinessTypeEntity.getAction().equals(ConstantType.SPLIT_OUT)) {
            for (IoCodeTempEntity codeTempEntity :codeTempEntities){
                IoSplitFifoCodeEntity fifoCodeEntity = fifoCodeService.findByCode(codeTempEntity.getCode(), null);
                if (fifoCodeEntity != null && StrUtil.isNotEmpty(fifoCodeEntity.getSerialNo())) {
                    return ResultVOUtils.error(500, "当前追溯码:" + fifoCodeEntity.getCode() +"已存在！");
                }
            }
        }
        //退货校验追溯码是否重复
        if (bussinessTypeEntity.getAction().equals(ConstantType.SPLIT_RETURN)) {
            for (IoCodeTempEntity codeTempEntity :codeTempEntities){
                IoSplitFifoCodeEntity fifoCodeEntity = fifoCodeService.findByCode(codeTempEntity.getCode(), null);
                if (fifoCodeEntity != null && StrUtil.isNotEmpty(fifoCodeEntity.getSerialNo())) {
                    return ResultVOUtils.error(500, "当前追溯码:" + fifoCodeEntity.getCode() +"已存在！");
                }
            }
        }

        String priceFifo = systemParamConfigService.selectValueByParamKey("price_fifo");
        if (IntUtil.value(priceFifo) > 0 && bussinessTypeEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
            List<IoCodeTempEntity> resultList = new ArrayList<>();
            for (IoCodeTempEntity codeTempEntity : codeTempEntities) {
                resultList = ioAddInoutService.checkPrice(codeTempEntity, bussinessTypeEntity, resultList);
            }
        }
        if (checkInoutService.checkManual(addOrderRequest.getBillNo())) {
            if (CollUtil.isNotEmpty(orderDetailBizEntities)) {

                if (bussinessTypeEntity.getCheckWebNew() == 1) {
                    String errMsg = checkInoutService.bizOrderCheck(orderDetailBizEntities, orderDetailCodeEntities);
                    if (StrUtil.isNotEmpty(errMsg)) {
                        return ResultVOUtils.error(500, errMsg);
                    }
                    errMsg = checkInoutService.codeOrderCheck(orderDetailCodeEntities, orderDetailBizEntities);
                    if (StrUtil.isNotEmpty(errMsg)) {
                        return ResultVOUtils.error(500, errMsg);
                    }
                    saveOrderWeb(addOrderRequest);
                    orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
                    orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
                    orderService.update(orderEntity);
                    checkInoutService.check(addOrderRequest.getBillNo());
                } else {
                    String errMsg = checkInoutService.bizNoPiCheck(orderDetailBizEntities, orderEntity);
                    if (StrUtil.isNotEmpty(errMsg)) {
                        return ResultVOUtils.error(500, errMsg);
                    }
                    orderDetailBizService.deleteByOrderId(addOrderRequest.getBillNo());
                    for (IoOrderDetailCodeEntity orderDetailCodeEntity : orderDetailCodeEntities) {
                        IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
                        BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailBizEntity);
                        orderDetailBizEntity.setId(null);
                        orderDetailBizEntity.setCount(IntUtil.value(orderDetailCodeEntity.getReCount()));
                        checkInoutService.getSomeBiz(orderDetailBizEntities, orderDetailBizEntity);
                        orderDetailBizService.insert(orderDetailBizEntity);
                    }
                    saveOrderWeb(addOrderRequest);
                    orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
                    orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
                    orderService.update(orderEntity);
                    ioAddInoutService.dealProcess(orderEntity);
                    checkInoutService.check(addOrderRequest.getBillNo());
                }


            } else {
                return ResultVOUtils.error(500, "单据校验提交失败,请先录入业务单据！");
            }
        } else {
            orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
            ioAddInoutService.dealProcess(orderEntity);
            checkInoutService.check(addOrderRequest.getBillNo());
            return ResultVOUtils.success("提交成功！");
        }

        return ResultVOUtils.success("提交成功！");
    }


    //    待校验提交,以扫码结果提交
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/codeResult/submitOrderWeb")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    @CusRedissonAnnotation(cacheName = RedissonCacheKey.SUBMIT_ORDER, key = {"#addOrderRequest.billNo"}, timeOutMsg = "系统正在处理，请勿重复提交")
    public BaseResponse submitByCodeResult(@RequestBody AddOrderRequest addOrderRequest) {

        IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
        BaseResponse tempResponse = checkSubmitEnable(orderEntity);
        if (tempResponse != null)
            return tempResponse;

        //校验单据是否已完成
        List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(addOrderRequest.getBillNo());
        if (CollUtil.isEmpty(orderDetailCodeEntities)) {
            return ResultVOUtils.error(500, "单据还未扫码或和扫码校验存在异常无法提交！");
        }
        saveOrderWeb(addOrderRequest);
        orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
        orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
        orderService.update(orderEntity);
        checkInoutService.checkCodeResult(addOrderRequest.getBillNo());
        return ResultVOUtils.success("提交成功！");
    }


    //待校验提交,以比对结果提交
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @Transactional(rollbackFor = Exception.class)
    @PostMapping("warehouse/inout/codeCheck/submitOrderWeb")
    @CusRedissonAnnotation(cacheName = RedissonCacheKey.SUBMIT_ORDER, key = {"#addOrderRequest.billNo"}, timeOutMsg = "系统正在处理，请勿重复提交")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse submitByCheckResult(@RequestBody AddOrderRequest addOrderRequest) {

        IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
        BaseResponse tempResponse = checkSubmitEnable(orderEntity);
        if (tempResponse != null)
            return tempResponse;

        //校验单据是否已完成
        List<IoCodeResponse> codeEntities = codeTempService.findJoinByOrderId(addOrderRequest.getBillNo());
        if (CollUtil.isEmpty(codeEntities)) {
            return ResultVOUtils.error(500, "单据还未扫码或和扫码校验存在异常无法提交！");
        }

        List<IoCodeResponse> codeTempEntities = getCheckRusultCode(addOrderRequest.getBillNo(), codeEntities);
        boolean isFull = false;
        for (IoCodeResponse codeTempEntity : codeTempEntities) {
            if (IntUtil.value(codeTempEntity.getCheckStatus()) == 2) {
                return ResultVOUtils.error(501, "存在多余条码，请先剔除后重新提交！");
            } else if (IntUtil.value(codeTempEntity.getCheckStatus()) == 0) {
                isFull = true;
            }
        }
        if (!isFull) {
            return ResultVOUtils.error(502, "校验结果不正确，无法提交！");
        }
        codeTempService.deleteByBillNo(addOrderRequest.getBillNo());
        for (IoCodeResponse codeResponse : codeTempEntities) {
            if (IntUtil.value(codeResponse.getCheckStatus()) == 0) {
                IoCodeTempEntity codeTempEntity = new IoCodeTempEntity();
                BeanUtils.copyProperties(codeResponse, codeTempEntity);
                codeTempService.insert(codeTempEntity);
            }
        }
        orderEntity.setStatus(ORDER_STATUS_CHECK_PROCESS);
        ioAddInoutService.dealProcess(orderEntity);
        checkInoutService.checkRightResult(addOrderRequest.getBillNo());
        return ResultVOUtils.success("提交成功！");

    }

    public BaseResponse checkSubmitEnable(IoOrderEntity orderEntity) {
        if (orderEntity == null) {
            return ResultVOUtils.error(500, "请先录入单据信息！");
        }
        if (orderEntity.getStatus() == ORDER_STATUS_CHECK_PROCESS || orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_PROCESS
                || orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_PROCESSING) {
            return ResultVOUtils.error(500, "提交失败，单据正在处理，请稍后刷新查看！");
        }
        if (orderEntity.getStatus() != 1 && orderEntity.getStatus() != 3 && orderEntity.getStatus() != 4 && orderEntity.getStatus() != 6) {
            return ResultVOUtils.error(500, "提交失败，单据已提交，请稍后刷新查看！");
        }
        return null;
    }

    @AuthRuleAnnotation("")
    @GetMapping("admin/warehouse/inout/findCheckCode")
    public BaseResponse findCheckCode(FilterCodeRequest filterCodeRequest) {
        //校验单据是否已完成
        List<IoCodeResponse> codeTempEntities = codeTempService.findJoinByOrderId(filterCodeRequest.getOrderId());
        List<IoCodeResponse> codeEntities = getCheckRusultCode(filterCodeRequest.getOrderId(), codeTempEntities);
        PageSimpleResponse<IoCodeResponse> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(0l);
        pageSimpleResponse.setList(codeEntities);
        return ResultVOUtils.success(pageSimpleResponse);
    }


    /**
     * PDA获取获取单据列表
     *
     * @param filterOrderRequest
     * @return
     */
    @AuthRuleAnnotation("")
    @PostMapping("/udiwms/inout/order/pda/list")
    public BaseResponse pdaListOrder(@RequestBody FilterOrderRequest filterOrderRequest) {

        if (StrUtil.isNotBlank(filterOrderRequest.getStatusType())) {
            orderService.setFilterStatus(filterOrderRequest);
        }
        if (StrUtil.isNotBlank(filterOrderRequest.getVueType())) {
            orderService.setActions(filterOrderRequest);
            if (CollUtil.isEmpty(filterOrderRequest.getActions())) {
                PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(new ArrayList<>());
                return ResultVOUtils.page(pageInfo);
            }
        }
        List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
        if (CollUtil.isEmpty(list))
            return ResultVOUtils.error(500, "未查询到单据");
        return ResultVOUtils.success(list);
    }


    /**
     * PDA获取待校验、待配货等单据
     *
     * @param filterOrderRequest
     * @return
     */
    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/inout/order/pda/download")
    public BaseResponse pdaFilterOrder(FilterOrderRequest filterOrderRequest) {

        if (StrUtil.isEmpty(filterOrderRequest.getBillNo())) {
            return ResultVOUtils.error(500, "单据号不能为空！");
        }
        if (StrUtil.isNotBlank(filterOrderRequest.getStatusType())) {
            orderService.setFilterStatus(filterOrderRequest);
        }
        if (StrUtil.isNotBlank(filterOrderRequest.getVueType())) {
            orderService.setActions(filterOrderRequest);
            //要是不存在要查询的单据类型就直接放回空
            if (CollUtil.isEmpty(filterOrderRequest.getActions())) {
                PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(new ArrayList<>());
                return ResultVOUtils.page(pageInfo);
            }
        }
        String customerId = getCustomerId();
        if (!customerId.equals("110")) {
            filterOrderRequest.setFromCorp(customerId);
        }
        List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
        if (CollUtil.isEmpty(list))
            return ResultVOUtils.error(501, "未查询到单据");
        FilterOrderDetailBizRequest filterOrderDetailBizRequest = new FilterOrderDetailBizRequest();
        filterOrderDetailBizRequest.setOrderIdFk(filterOrderRequest.getBillNo());
        List<IoOrderDetailBizResponse> orderDetailBizResponses = orderDetailBizService.filterList(filterOrderDetailBizRequest);
        IoOrderPdaResponse orderPdaResponse = new IoOrderPdaResponse();
        orderPdaResponse.setOrderResponse(list.get(0));
        orderPdaResponse.setOrderDetailBizResponses(orderDetailBizResponses);
//        PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
        return ResultVOUtils.success(orderPdaResponse);
    }


    public List<IoCodeTempEntity> getOtherCode(String billNo, List<IoCodeTempEntity> codeEntities) {
        List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(billNo);

        for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
            bizEntity.setCheckSuccess(false);
            bizEntity.setScanCount(0);
        }
        for (IoCodeTempEntity codeTempEntity : codeEntities) {
            codeTempEntity.setCheckSuccess(false);
        }
        List<IoCodeTempEntity> otherCodes = new ArrayList<>();
        for (IoCodeTempEntity codeEntity : codeEntities) {
            for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
                if (checkId(bizEntity, codeEntity) == null
                        && checkBatchNo(bizEntity, codeEntity) == null
                        && checkProductDate(bizEntity, codeEntity) == null
                        && checkExpireDate(bizEntity, codeEntity) == null) {
                    int curCount = IntUtil.value(codeEntity.getReCount()) + bizEntity.getScanCount();
                    if (bizEntity.getCount() < curCount) {
                        otherCodes.add(codeEntity);
                    } else {
                        bizEntity.setScanCount(curCount);
                    }
                    codeEntity.setCheckSuccess(true);
                    break;
                }
            }
            if (!codeEntity.isCheckSuccess()) {
                otherCodes.add(codeEntity);
            }
        }
        return otherCodes;
    }

    public List<IoCodeResponse> getCheckRusultCode(String billNo, List<IoCodeResponse> codeEntities) {
        List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(billNo);
        List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(billNo);
        List<IoOrderCheckResultResponse> orderCheckResultResponses = ioCheckInoutService.combineCheck(orderDetailBizEntities, orderDetailCodeEntities);
        if (CollUtil.isNotEmpty(orderCheckResultResponses)) {
            for (IoOrderCheckResultResponse orderCheckResultResponse : orderCheckResultResponses) {
                for (IoCodeResponse codeTempEntity : codeEntities) {
                    if (IntUtil.value(codeTempEntity.getRelId()) == IntUtil.value(orderCheckResultResponse.getBindRlFk())
                            && (StrUtil.nullToEmpty(codeTempEntity.getBatchNo()).equals(StrUtil.nullToEmpty(orderCheckResultResponse.getBBatchNo()))
                            || StrUtil.nullToEmpty(codeTempEntity.getBatchNo()).equals(StrUtil.nullToEmpty(orderCheckResultResponse.getSBatchNo())
                    ))) {
                        if (orderCheckResultResponse.getCount() < 1) {
                            codeTempEntity.setCheckStatus(1);
                        } else if (orderCheckResultResponse.getCount() < orderCheckResultResponse.getScanCount()) {
                            codeTempEntity.setCheckStatus(2);
                        }
                    }
                    UdiProductEntity drug = udiProductDao.findByNameCode(codeTempEntity.getNameCode());
                    if (drug.getProductsType() == 2) {
                        //药品添加药品数据
                        codeTempEntity.setBzgg(drug.getBzgg());
                        codeTempEntity.setPrepnUnit(drug.getPrepnUnit());
                        codeTempEntity.setPrepnSpec(drug.getPrepnSpec());
                        codeTempEntity.setSpec(drug.getGgxh());
                    }
                }
            }
        }
        return codeEntities;
    }


    //带配货-立即提交
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/waitAllocate/submitOrderWeb")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse submitWaitAllocateWeb(@RequestBody AddOrderRequest addOrderRequest) {

        //校验单据是否已完成
        IoOrderEntity orderEntity = orderService.findByBillNo(addOrderRequest.getBillNo());
        BaseResponse tempResponse = checkSubmitEnable(orderEntity);
        if (tempResponse != null)
            return tempResponse;

        List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(addOrderRequest.getBillNo());
        List<IoOrderDetailCodeEntity> orderDetailCodeEntities = orderDetailCodeService.findByOrderId(addOrderRequest.getBillNo());

        if (CollUtil.isEmpty(orderDetailCodeEntities)) {
            return ResultVOUtils.error(500, "单据还未扫码或和扫码校验存在异常无法提交！");
        }
        String errMsg = checkInoutService.bizNoPiCheck(orderDetailBizEntities, orderEntity);
        if (StrUtil.isNotEmpty(errMsg)) {
            return ResultVOUtils.error(500, errMsg);
        }
        orderDetailBizService.deleteByOrderId(addOrderRequest.getBillNo());
        for (IoOrderDetailCodeEntity orderDetailCodeEntity : orderDetailCodeEntities) {
            IoOrderDetailBizEntity orderDetailBizEntity = new IoOrderDetailBizEntity();
            BeanUtils.copyProperties(orderDetailCodeEntity, orderDetailBizEntity);
            orderDetailBizEntity.setCount(IntUtil.value(orderDetailCodeEntity.getReCount()));
            orderDetailBizEntity.setId(null);
            checkInoutService.getSomeBiz(orderDetailBizEntities, orderDetailBizEntity);
            orderDetailBizService.insert(orderDetailBizEntity);
        }
        saveOrderWeb(addOrderRequest);
        orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK);
        orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
        orderService.update(orderEntity);

        ioAddInoutService.dealProcess(orderEntity);
        checkInoutService.check(addOrderRequest.getBillNo());
        return ResultVOUtils.success("提交成功！");
    }


    @Resource
    IoCodeService codeService;

    //未校验单据删除
    @AuthRuleAnnotation("")
    @PostMapping("udiwms/inout/order/delete")
    @Log(title = "单据管理", businessType = BusinessType.DELETE)
    public BaseResponse deletById(@RequestBody DeleteRequest deleteRequest) {
        IoOrderEntity orderEntity = orderService.findByBillNo(deleteRequest.getBillNo());
        if (orderEntity.getStatus() != 1 && orderEntity.getStatus() != 3 && orderEntity.getStatus() != 4 && orderEntity.getStatus() != 6 && orderEntity.getStatus() != 10) {
            return ResultVOUtils.error(500, "单据已提交无法删除！");
        }
        orderService.deleteByBillNo(deleteRequest.getBillNo());
        orderDetailBizService.deleteByOrderId(deleteRequest.getBillNo());
        orderDetailCodeService.deleteByOrderId(deleteRequest.getBillNo());
        codeTempService.deleteByBillNo(deleteRequest.getBillNo());
        codeService.deleteCodeByOrderId(deleteRequest.getBillNo());
        return ResultVOUtils.success("删除成功！");
    }


    //已验收单据删除、单据编辑删除等
    @AuthRuleAnnotation("")
    @PostMapping("udiwms/inout/order/finish/delete")
    @Log(title = "单据管理", businessType = BusinessType.DELETE)
    public BaseResponse deleteById(@RequestBody DeleteRequest deleteRequest) {
        List<String> delBillNos = new ArrayList<>();
        if (CollUtil.isNotEmpty(deleteRequest.getBillNos())) {
            delBillNos.addAll(deleteRequest.getBillNos());
        } else {
            delBillNos.add(deleteRequest.getBillNo());
        }
        orderService.deleteInvByBillNo(delBillNos);
        for (String billNo : delBillNos) {
            orderService.deleteByBillNo(billNo);
            orderDetailBizService.deleteByOrderId(billNo);
            orderDetailCodeService.deleteByOrderId(billNo);
            codeTempService.deleteByBillNo(billNo);
            codeService.deleteCodeByOrderId(billNo);
        }
        ThreadUtil.execAsync(() -> {
            BaseResponse response = spGetHttpClient.postDelOrder(deleteRequest);
            log.info("删除单据：" + "结果：" + response.getMessage());
        });
        return ResultVOUtils.success("删除成功！");
    }

    @Resource
    public RedisUtil redisUtil;

    /**
     * 为平潭写的删除科室出库的单据,验收完后需要删掉
     *
     * @return
     */
    @AuthRuleAnnotation("")
    @PostMapping("udiwms/inout/order/finish/pt/delete")
    @Log(title = "单据管理", businessType = BusinessType.DELETE)
    public BaseResponse deleteAll(@RequestBody DeleteRequest deleteRequest) {

        List<IoOrderEntity> orderEntities = orderService.findAllByAction("SC71021292871198");
        Boolean b = redisUtil.getBool("deleteAllOrder");
        if (b)
            return ResultVOUtils.error("当前删除任务正在执行，请勿重复点击！");
        redisUtil.set("deleteAllOrder", true);
        orderEntities.parallelStream().forEach(item ->
                {
                    List<String> delBillNos = new ArrayList<>();
                    delBillNos.add(item.getBillNo());
                    orderService.deleteInvByBillNo(delBillNos);
                    for (String billNo : delBillNos) {
                        orderService.deleteByBillNo(billNo);
                        orderDetailBizService.deleteByOrderId(billNo);
                        orderDetailCodeService.deleteByOrderId(billNo);
                        codeTempService.deleteByBillNo(billNo);
                        codeService.deleteCodeByOrderId(billNo);
                    }
                }
        );
        redisUtil.set("deleteAllOrder", false);
        return ResultVOUtils.success("删除成功！");
    }

    //单据编辑，条码减一
    @AuthRuleAnnotation("")
    @PostMapping("udiwms/inout/code/finish/delete")
    @Log(title = "单据管理", businessType = BusinessType.DELETE)
    public BaseResponse deleteCodeById(@RequestBody IoCodeEntity codeEntity) {
        orderService.deleteInvCode(codeEntity, false);
        return ResultVOUtils.success("删除成功！");
    }

    //单据编辑，条码减一
    @AuthRuleAnnotation("")
    @PostMapping("udiwms/inout/code/finish/deleteAll")
    @Log(title = "单据管理", businessType = BusinessType.DELETE)
    public BaseResponse deleteCodeAllById(@RequestBody IoCodeEntity codeEntity) {
        orderService.deleteInvCode(codeEntity, true);
        return ResultVOUtils.success("删除成功！");
    }


    //已验收单据撤回
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/inout/order/received/rollback")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse rollbackOrder(String billNo) {
        if (StrUtil.isBlank(billNo)) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }

        IoOrderEntity orderEntity = orderService.findByBillNo(billNo);
        if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_AUDITED) {
            if (StrUtil.isNotEmpty(orderEntity.getSupplementNo()) || StrUtil.isNotEmpty(orderEntity.getUllageSupNo())) {
                return ResultVOUtils.error(500, "单据已补单，无法撤回！");
            }
            if (orderEntity.getSyncStatus() != null && orderEntity.getSyncStatus() == 1) {
                return ResultVOUtils.error(500, "单据已同步，无法撤回！");
            }
            boolean result = orderService.rollbackOrder(billNo);
            if (result) {
                return ResultVOUtils.success();
            }
            return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");
        } else if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_CHECK_REW) {

            orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_SUCCESS);
            orderService.update(orderEntity);
            return ResultVOUtils.success("撤回成功！");

        } else if (orderEntity.getStatus() == ConstantStatus.ORDER_STATUS_CHECK_SUCCESS) {
            if (StrUtil.isBlank(billNo)) {
                return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
            }
            boolean result = orderService.rollbackUnReOrder(billNo);
            if (result) {
                return ResultVOUtils.success("撤回成功！");
            }
            return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");
        }
        return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");

    }


    //已校验单据撤回到等待处理
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/inout/order/unReceive/rollback")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse rollUnReceivebackOrder(String billNo) {
        if (StrUtil.isBlank(billNo)) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        boolean result = orderService.rollbackUnReOrder(billNo);
        if (result) {
            return ResultVOUtils.success("撤回成功！");
        }
        return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");
    }

    //待校验撤回草稿
    @RepeatSubmit()
    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/inout/order/waitCheck/rollback")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse rollUnCheckOrder(String billNo) {
        if (StrUtil.isBlank(billNo)) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        boolean result = orderService.rollUnCheckOrder(billNo);
        if (result) {
            return ResultVOUtils.success("撤回成功！");
        }
        return ResultVOUtils.error(ResultEnum.NOT_NETWORK, "撤回失败");
    }


    //手持终端获取未处理业务单据进行校验
    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/erpOrder/filter")
    public BaseResponse filterErpOrder(FilterOrderRequest filterOrderRequest,
                                       BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        if (StrUtil.isEmpty(filterOrderRequest.getAction()))
            return ResultVOUtils.error(500, "单据类型不能为空！");
        List<IoOrderResponse> orderResponses = orderService.filterList(filterOrderRequest);
        List<PdaBusOrderResponse> erpOrderResponses = new ArrayList<>();
        if (CollUtil.isNotEmpty(orderResponses)) {
            for (IoOrderResponse orderResponse : orderResponses) {
                PdaBusOrderResponse pdaBusOrderResponse = new PdaBusOrderResponse();
                BeanUtils.copyProperties(orderResponse, pdaBusOrderResponse);
                FilterOrderDetailBizRequest filterOrderDetailBizRequest = new FilterOrderDetailBizRequest();
                filterOrderDetailBizRequest.setOrderIdFk(orderResponse.getBillNo());
                List<IoOrderDetailBizResponse> orderDetailBizEntities = orderDetailBizService.filterList(filterOrderDetailBizRequest);
                pdaBusOrderResponse.setOrderDetailBizResponses(orderDetailBizEntities);
                erpOrderResponses.add(pdaBusOrderResponse);
            }
        }
        PageInfo<IoOrderResponse> pageInfo;
        pageInfo = new PageInfo<>(orderResponses);
        PageSimpleResponse<PdaBusOrderResponse> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        pageSimpleResponse.setList(erpOrderResponses);
        return ResultVOUtils.success(pageSimpleResponse);
    }

    @Resource
    EntrustReceService entrustReceService;
    @Resource
    InvBusUserService invBusUserService;

    //手持终端下载扫码单据进行审核
    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/inout/order/download")
    public BaseResponse downloadOrder(FilterOrderRequest filterOrderRequest,
                                      BindingResult bindingResult) {

        if (bindingResult.hasErrors()) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL, bindingResult.getFieldError().getDefaultMessage());
        }
        Long userId = null;
        if (filterOrderRequest.getWmsUserId() != null) {
            userId = filterOrderRequest.getWmsUserId();
        } else userId = getUserId();

        List<EntrustReceEntity> entrustReceEntities;
        List<InvBusUserEntity> warehouseUserEntities = null;
        IoOrderEntity stockOrderEntity = orderService.findByBillNo(filterOrderRequest.getBillNo());
        if (stockOrderEntity == null) {
            return ResultVOUtils.error(500, "单据未找到！");
        } else if (stockOrderEntity.getStatus() == ConstantStatus.ORDER_STATUS_CHECK_SUCCESS) {

            //1.校验是否为委托验收人
            if (!stockOrderEntity.isEntrustEnd()) {
                BasicEntrustRecRequest basicEntrustRecRequest = new BasicEntrustRecRequest();
                basicEntrustRecRequest.setAction(stockOrderEntity.getAction());
                basicEntrustRecRequest.setEntrustUser(userId);
                basicEntrustRecRequest.setCurInv(stockOrderEntity.getInvCode());
                entrustReceEntities = entrustReceService.filterEntrustRec(basicEntrustRecRequest);
            } else {
                return ResultVOUtils.error(500, "单据已委托验收完成！");
            }

            //2.校验是否为用户所属单据类型
            if (StrUtil.isNotEmpty(stockOrderEntity.getDeptCode())) {
                FilterInvBusUserRequest filterInvBusUserRequest = new FilterInvBusUserRequest();
                filterInvBusUserRequest.setSubInvCode(stockOrderEntity.getInvCode());
                filterInvBusUserRequest.setUserId(userId + "");
                filterInvBusUserRequest.setScAction(stockOrderEntity.getAction());
                warehouseUserEntities = invBusUserService.filterInvBusUser(filterInvBusUserRequest);
            }

            if (CollUtil.isEmpty(warehouseUserEntities) && CollUtil.isEmpty(entrustReceEntities)) {
                return ResultVOUtils.error(500, "权限不足，无法验收！");
            }
        } else if (stockOrderEntity.getStatus() == ConstantStatus.ORDER_STATUS_AUDITED) {
            return ResultVOUtils.error(500, "单据已审核！");
        } else {
            return ResultVOUtils.error(500, "非未审核单据！");
        }

        List<IoOrderResponse> orderEntityList = orderService.filterList(filterOrderRequest);
        PageInfo<IoOrderResponse> pageInfo;
        pageInfo = new PageInfo<>(orderEntityList);
        PageSimpleResponse<IoOrderResponse> pageSimpleResponse = new PageSimpleResponse<>();
        pageSimpleResponse.setTotal(pageInfo.getTotal());
        pageSimpleResponse.setList(orderEntityList);
        return ResultVOUtils.success(pageSimpleResponse);
    }

    /**
     * 单据编辑页面查询单据接口
     *
     * @param billNo
     * @return
     */
    @GetMapping("udiwms/inout/order/filterOrderTrace")
    public BaseResponse filterOrderTrace(String billNo, Integer productType) {
        if (StrUtil.isBlank(billNo)) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        if (productType == null) {
            productType = 1;
        }
        //只用于单据维护   加了状态判断了
        List<IoOrderEntity> list = orderService.filterOrderTrace(billNo, productType);
        List<IoOrderResponse> responses = orderService.findResponse(list);
        return ResultVOUtils.success(responses);
    }

    /**
     * 批量修改单据信息
     *
     * @return
     */
    @PostMapping("/udiwms/inout/order/updateOrderInfo")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse updateOrderInfo(@RequestBody OrderEditRequest orderEditRequest) {
        if (null == orderEditRequest || CollUtil.isEmpty(orderEditRequest.getOrderIds())) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        orderService.updateOrderInfo(orderEditRequest);
        return ResultVOUtils.success();
    }

    /**
     * 查询上传单据
     *
     * @param uploadOrderRequest
     * @return
     */
    @GetMapping("/udiwms/inout/order/upload/filter")
    public BaseResponse filterUploadOrder(FilterUploadOrderRequest uploadOrderRequest) {
        List<IoOrderResponse> list = orderService.filterUploadOrderList(uploadOrderRequest);
        PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
        return ResultVOUtils.page(pageInfo);
    }

    /**
     * 上传单据到第三方系统
     *
     * @param billNo
     * @return
     */
    @RepeatSubmit()
    @GetMapping("/udiwms/inout/order/submitToThrSys")
    public BaseResponse submitToThrSys(@RequestParam("billNo") String billNo) {
        if (StrUtil.isBlank(billNo)) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        return orderService.submitToThrSys(billNo);
    }

    @PostMapping("/udiwms/inout/order/updateOrderDetailBiz")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse updateOrderDetailBiz(@RequestBody IoOrderDetailBizEntity ioOrderDetailBizEntity) {
        if (null == ioOrderDetailBizEntity) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
//        ioOrderDetailBizEntity.setCheckFileName(ioOrderDetailBizEntity.getCheckFileName().substring(0,ioOrderDetailBizEntity.getCheckFileName().length() - 4));
        orderDetailBizService.updateOrderDetailBiz(ioOrderDetailBizEntity);
        return ResultVOUtils.success();
    }

    @Resource
    SpGetHttpClient spGetHttpClient;

    @PostMapping("/udiwms/inout/order/updateOrder")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse updateOrder(@RequestBody IoOrderEntity ioOrderEntity) {

        ioOrderEntity.setUpdateTime(new Date());
        ioOrderEntity.setUpdateUser(getUserId() + "");
        ioOrderEntity.setConfirmUser(getUserId() + "");
        ioOrderEntity.setConfirmTime(new Date());

        if (IntUtil.value(ioOrderEntity.getCheckStatus()) != 0) {
            ioOrderEntity.setConfirmTime(new Date());
            orderService.updateByBillNo(ioOrderEntity);
            IoOrderEntity orderEntity = new IoOrderEntity();
            orderEntity.setBillNo(ioOrderEntity.getBillNo());
            orderEntity.setCheckStatus(1);
            spGetHttpClient.updateCheckStatus(orderEntity, getUserId() + "");
        } else {
            orderService.updateByBillNo(ioOrderEntity);
        }
        return ResultVOUtils.success();
    }


    @Resource
    GennerOrderUtils gennerOrderUtils;
    @Resource
    InvWarehouseService invWarehouseService;

    @AuthRuleAnnotation("")
    @CusRedissonAnnotation(cacheName = RedissonCacheKey.COPY_ORDER, key = {"#addOrderChangeRequest.orderId"}, timeOutMsg = "系统正在处理，请勿重复提交")
    @PostMapping("/udiwms/stock/order/change")
    public BaseResponse stockOrderChange(@RequestBody AddOrderChangeRequest addOrderChangeRequest) {

        AuthAdmin authAdmin = getUser();
        IoOrderEntity originOrder = orderService.findByBillNo(addOrderChangeRequest.getOrderId());
        IoOrderEntity newOrder = new IoOrderEntity();
        List<IoCodeEntity> originCodes = codeService.findByOrderId(originOrder.getBillNo());
        newOrder.setCreateTime(new Date());
        newOrder.setFromCorp(addOrderChangeRequest.getFromCorp());

        newOrder.setFromInvCode(addOrderChangeRequest.getFromInvCode());
        if (addOrderChangeRequest.getFromInvCode() != null) {
            InvWarehouseEntity fromInv = invWarehouseService.findByInvSubByCode(addOrderChangeRequest.getFromInvCode());
            newOrder.setFromDeptCode(fromInv.getParentId());
        }

        newOrder.setCreateUser(authAdmin.getId() + "");
        newOrder.setUpdateUser(authAdmin.getId() + "");
        InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByInvSubByCode(addOrderChangeRequest.getInvCode());
        newOrder.setInvCode(addOrderChangeRequest.getInvCode());
        newOrder.setDeptCode(invWarehouseEntity.getParentId());
        newOrder.setCorpOrderId(CustomUtil.getId() + "x");

        BasicBussinessTypeEntity basicBussinessTypeEntity = basicBussinessTypeService.findByAction(addOrderChangeRequest.getAction());
        newOrder.setAction(addOrderChangeRequest.getAction());
        newOrder.setMainAction(basicBussinessTypeEntity.getMainAction());

        newOrder.setExportStatus(0);  //设置导出状态为未导出
        newOrder.setDealStatus(ConstantStatus.ORDER_DEAL_DRAFT);//设置单据未草稿状态
        newOrder.setStatus(ConstantStatus.ORDER_STATUS_TEMP_SAVE); //设置验收状态为未验收
        newOrder.setFromType(ConstantStatus.FROM_COPY);
        newOrder.setOrderType(2);
        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(addOrderChangeRequest.getAction());
        String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
        String supplementOrderNo = orderNo;
        newOrder.setBillNo(supplementOrderNo);
        newOrder.setReplicateNo(null); //新单据的复制单号置空
        newOrder.setRemark(addOrderChangeRequest.getRemark());
        originOrder.setReplicateNo(orderNo);
        List<IoCodeTempEntity> supplementCodes = new ArrayList<>();

        List<IoCodeEntity> products = addOrderChangeRequest.getProducts();
        List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(originOrder.getBillNo());
        // 计算出两个集合之间产品批次号组成的差异
        List<IoOrderDetailBizEntity> insertBizList = orderDetailBizEntities.stream()
                .filter(comment -> products.stream()
                        .anyMatch(p -> Objects.equals(p.getBatchNo(), comment.getBatchNo()) // 使用 Objects.equals 来进行非空判断
                                && Objects.equals(p.getRelId(), comment.getBindRlFk())))
                .collect(Collectors.toList());
        //生成业务单
        if (CollUtil.isNotEmpty(insertBizList)) {
            for (IoOrderDetailBizEntity orderDetailBizEntity : insertBizList) {
                orderDetailBizEntity.setOrderIdFk(newOrder.getBillNo());
                orderDetailBizEntity.setId(IdUtil.getSnowflakeNextId());


                if (bussinessTypeEntity.isScanPreIn()) {    //校验预验收库存

                    if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_NULL) {
                        BaseResponse invRes = checkPreInInv(orderDetailBizEntity);
                        if (invRes != null) {
                            return invRes;
                        }
                    }
                } else if (bussinessTypeEntity.isAdvancePreIn()) {  //校验寄售库存
                    if (bussinessTypeEntity.getSpaceOut() == ConstantStatus.SPACE_OUT_NULL) {
                        BaseResponse invRes = checkPreInv(orderDetailBizEntity);
                        if (invRes != null) {
                            return invRes;
                        }
                    }
                } else {
                    if (bussinessTypeEntity.isVailInv() && bussinessTypeEntity.getMainAction().equals(ConstantType.TYPE_OUT)) {
                        BaseResponse invRes = checkInv(orderDetailBizEntity, newOrder);
                        if (invRes != null) {
                            return invRes;
                        }
                    }

                }
            }
            orderDetailBizService.batchInsertBizs(insertBizList);
        }

        originCodes.forEach(
                code -> {
                    //复制选中的产品
                    for (IoCodeEntity product : products) {
                        if (product.getRelId().equals(code.getRelId())) {
                            if ((StrUtil.isNotBlank(product.getBatchNo()) && StrUtil.isNotBlank(code.getBatchNo()) && product.getBatchNo().equals(code.getBatchNo()))
                                    || (StrUtil.isBlank(product.getBatchNo()) && StrUtil.isBlank(code.getBatchNo()))) {
                                IoCodeTempEntity supplementCode = new IoCodeTempEntity();
                                BeanUtils.copyProperties(code, supplementCode);
                                supplementCode.setInvCode(newOrder.getInvCode());
                                supplementCode.setDeptCode(newOrder.getDeptCode());
                                supplementCode.setOrderId(newOrder.getBillNo());
                                supplementCode.setCorpOrderId(newOrder.getCorpOrderId());
                                //查询补单设置
                                supplementCode.setAction(newOrder.getAction());
                                supplementCode.setMainAction(newOrder.getMainAction());
                                supplementCode.setUpdateTime(new Date());
                                supplementCode.setCreateTime(new Date());
                                supplementCode.setId(null);
                                supplementCodes.add(supplementCode);
                                break;
                            }
                        }
                    }
                }
        );
        newOrder.setUpdateTime(new Date());
        orderService.insertOrder(newOrder);
        codeTempService.insertBatch(supplementCodes);
        orderService.update(originOrder);

        ioAddInoutService.dealProcess(newOrder);
        //不需要手动校验，则走正常单据校验处理流程
        if (!ioCheckInoutService.checkManual(newOrder.getBillNo())) {
            ioCheckInoutService.check(newOrder.getBillNo());
        }

        return ResultVOUtils.success();
    }

    @GetMapping("/udiwms/inout/order/getUserBean")
    public BaseResponse getUserBean() {
        AuthAdmin userBean = customerService.getUserBean();
        return ResultVOUtils.success(userBean);
    }

    @AuthRuleAnnotation("")
    @GetMapping("/udiwms/inout/order/filterInvoiceList")
    public BaseResponse filterInvoiceList(FilterOrderRequest filterOrderRequest) {

        //这个不等于空表示要查询发票对应的单据
        if (filterOrderRequest.getInvoiceEncode() != null) {
            //查询发票详情
            QueryWrapper<IoOrderInvoiceEntity> ew = new QueryWrapper<IoOrderInvoiceEntity>();
            ew.eq("invoiceEncode", filterOrderRequest.getInvoiceEncode());
            List<IoOrderInvoiceEntity> ioOrderInvoiceEntity = orderInvoiceService.list(ew);
            List<String> orderIds = ioOrderInvoiceEntity.stream().map(IoOrderInvoiceEntity::getOrderIdFk).collect(Collectors.toList());
            filterOrderRequest.setOrderIds(orderIds);
            if (CollectionUtils.isEmpty(orderIds)) {
                PageInfo<IoOrderResponse> pageInfo = new PageInfo<>();
                return ResultVOUtils.page(pageInfo);
            }
        }


        if (StrUtil.isNotBlank(filterOrderRequest.getStatusType())) {
            orderService.setFilterStatus(filterOrderRequest);
        }
        if (StrUtil.isNotBlank(filterOrderRequest.getVueType())) {
            orderService.setActions(filterOrderRequest);
        }

        if (StrUtil.isNotEmpty(filterOrderRequest.getSupInoivceSearch())) {
            orderService.setInvoiceFiltes(filterOrderRequest);
        }
        if (filterOrderRequest.getSourceLocalType() != null) {
            if (filterOrderRequest.getSourceLocalType() == 1) {
                filterOrderRequest.setSourceTypes(Arrays.asList(1, 2, 3, 4, 5));
            } else {
                filterOrderRequest.setSourceTypes(Arrays.asList(6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 17));
            }
        }
        String customerId = getCustomerId();
        if (!customerId.equals("110")) {
            filterOrderRequest.setFromCorp(customerId);
        }
        List<IoOrderResponse> list = orderService.getfilterOrderList(filterOrderRequest);

        for (IoOrderResponse ioOrderResponse : list) {
            if (ioOrderResponse.getCheckStatus() == null) {
                ioOrderResponse.setCheckStatus(0 + "");
            }
            orderInvoiceService.findRegStausByBillNo(ioOrderResponse);
        }
        if (filterOrderRequest.getInvoiceEncode() == null) {
            //查询已被登记的单据
            List<IoOrderInvoiceEntity> ioOrderInvoiceEntity = orderInvoiceService.list();
            //已被选择的单据做标记
            if (ioOrderInvoiceEntity != null && ioOrderInvoiceEntity.size() > 0) {
                for (IoOrderResponse ioOrderResponse : list) {
                    for (IoOrderInvoiceEntity orderInvoiceEntity : ioOrderInvoiceEntity) {
                        if (ioOrderResponse.getBillNo().equals(orderInvoiceEntity.getOrderIdFk())) {
                            ioOrderResponse.setCheckType(true);
                            break;
                        }
                    }
                }
            }
        }
        PageInfo<IoOrderResponse> pageInfo = new PageInfo<>(list);
        return ResultVOUtils.page(pageInfo);
    }


    public String checkId(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {

        if (bizEntity.getBindRlFk().longValue() == codeEntity.getRelId().longValue()) {
            return null;
        } else {
            return "产品ID不匹配";
        }
    }

    public String checkBatchNo(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {

        if (StrUtil.nullToEmpty(bizEntity.getBatchNo()).equals(StrUtil.nullToEmpty(codeEntity.getBatchNo()))) {
            return null;
        } else {
            return bizEntity.getCoName() + "批次号不匹配";
        }
    }

    public String checkProductDate(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {
        if (StrUtil.nullToEmpty(bizEntity.getProductDate()).equals(StrUtil.nullToEmpty(codeEntity.getProduceDate()))) {
            return null;
        } else {
            return bizEntity.getCoName() + "生产日期不匹配";
        }
    }

    public String checkExpireDate(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {
        if (StrUtil.nullToEmpty(bizEntity.getExpireDate()).equals(StrUtil.nullToEmpty(codeEntity.getExpireDate()))) {
            return null;
        } else {
            return bizEntity.getCoName() + "失效日期不匹配";
        }
    }

    public String checkCount(IoOrderDetailBizEntity bizEntity, IoCodeTempEntity codeEntity) {
        if (IntUtil.value(bizEntity.getCount()) == IntUtil.value(codeEntity.getReCount())) {
            return null;
        }
        return bizEntity.getCoName() + "数量不匹配！";
    }


    public BaseResponse checkInv(IoOrderDetailBizEntity bizEntity, IoOrderEntity orderEntity) {
        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(orderEntity.getAction());
        String outInvCode = orderEntity.getInvCode();
        InvWarehouseEntity invWarehouseEntity = invWarehouseService.findNoInvTypeInv(bussinessTypeEntity.getDeptNoInvType(), outInvCode);
        if (invWarehouseEntity != null) {
            outInvCode = invWarehouseEntity.getCode();
        }
        int count = 0;
        count = invProductDetailService.vailStockCount(bizEntity.getBindRlFk(), bizEntity.getBatchNo(), bizEntity.getSupId(), null, outInvCode, null, true);
        if (count < 0) {
            if (count == -1) {
                return ResultVOUtils.error(500, "该产品未入库");
            } else
                return ResultVOUtils.error(500, "当前库存不足");
        }
        return null;
    }

    /**
     * 校验寄售库存
     */
    public BaseResponse checkPreInv(IoOrderDetailBizEntity bizEntity) {

        InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByOne(ConstantStatus.ACTION_TYPE_ADVANCE);
        int count = 0;
        count = invPreProductDetailService.vailStockCount(bizEntity.getBindRlFk(), bizEntity.getBatchNo(), bizEntity.getSupId(), null, invWarehouseEntity.getCode(), null);
        if (count <= 0) {
            if (count == -1) {
                return ResultVOUtils.error(500, "该产品未入库");
            } else
                return ResultVOUtils.error(500, "寄售库存数量不足！");
        }
        return null;
    }

    //     校验预验收库存
    public BaseResponse checkPreInInv(IoOrderDetailBizEntity bizEntity) {

        InvWarehouseEntity invWarehouseEntity = invWarehouseService.findByOne(ConstantStatus.ACTION_TYPE_PREIN);
        int count = 0;
        count = invPreinProductDetailService.vailStockCount(bizEntity.getBindRlFk(), bizEntity.getBatchNo(), bizEntity.getSupId(), null, invWarehouseEntity.getCode(), null);
        if (count <= 0) {
            if (count == -1) {
                return ResultVOUtils.error(500, "该产品未入库");
            } else
                return ResultVOUtils.error(500, "预验收库存数量不足！");
        }
        return null;
    }


}