udi-spms-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.util.StrUtil;
import com.github.pagehelper.PageInfo;
import com.glxp.api.annotation.AuthRuleAnnotation;
import com.glxp.api.annotation.Log;
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.BusinessType;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.controller.BaseController;
import com.glxp.api.entity.auth.InvBusUserEntity;
import com.glxp.api.entity.basic.BasicBussinessTypeEntity;
import com.glxp.api.entity.basic.EntrustReceEntity;
import com.glxp.api.entity.inout.*;
import com.glxp.api.req.auth.FilterInvBusUserRequest;
import com.glxp.api.req.basic.BasicEntrustRecRequest;
import com.glxp.api.req.inout.*;
import com.glxp.api.req.system.DeleteRequest;
import com.glxp.api.req.udims.PostUdimsOrderRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.inout.IoOrderDetailBizResponse;
import com.glxp.api.res.inout.IoOrderDetailCodeResponse;
import com.glxp.api.res.inout.IoOrderResponse;
import com.glxp.api.res.inout.PdaBusOrderResponse;
import com.glxp.api.service.auth.InvBusUserService;
import com.glxp.api.service.basic.EntrustReceService;
import com.glxp.api.service.basic.IBasicBussinessTypeService;
import com.glxp.api.service.inout.*;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.scheduling.annotation.Async;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.*;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

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


@Slf4j
@RestController
@Api("单据相关")
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;

    /**
     * 查询单据列表
     *
     * @param filterOrderRequest
     * @return
     */

    @ApiOperation(value = "获取单据列表", response = IoOrderResponse.class)
    @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 (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);
        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())) {
            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.getfilterList(filterOrderRequest);

        for (IoOrderResponse ioOrderResponse : list) {
            if (ioOrderResponse.getCheckStatus() == null) {
                ioOrderResponse.setCheckStatus(0 + "");
            }
            FilterOrderDetailCodeRequest filterOrderDetailCodeRequest = new FilterOrderDetailCodeRequest();
            filterOrderDetailCodeRequest.setOrderIdFk(ioOrderResponse.getBillNo());
            List<IoOrderDetailCodeResponse> ioOrderDetailCodeResponses = orderDetailBizService.getfilterList(filterOrderDetailCodeRequest);
            BigDecimal amount = new BigDecimal(0.00);
            for (IoOrderDetailCodeResponse ioOrderDetailCodeRespons : ioOrderDetailCodeResponses) {
                if (ioOrderDetailCodeRespons.getCount() != 0 && ioOrderDetailCodeRespons.getPrice() != null) {
                    amount = amount.add(new BigDecimal(ioOrderDetailCodeRespons.getCount()).multiply(ioOrderDetailCodeRespons.getPrice()));
                }
            }
            ioOrderResponse.setAllAmount(amount);


        }


        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/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, "请先录入产品！");
        }

        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 (orderDetailBizEntity.getCount() == 0) {
                return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "产品数量不能为0！");
            }
            if (addOrderRequest.getFromVailPi() != 2 &&
                    StrUtil.isEmpty(orderDetailBizEntity.getBatchNo())
                    && StrUtil.isEmpty(orderDetailBizEntity.getProductDate())
                    && StrUtil.isEmpty(orderDetailBizEntity.getExpireDate())) {
                return ResultVOUtils.error(500, orderDetailBizEntity.getCoName() + "三期不能全为空！");
            }
        }

        ioAddInoutService.dealBusProcess(orderEntity, addOrderRequest.getFromVailPi());
        return ResultVOUtils.success("提交成功！");
    }

    //新增扫码单据-立即提交
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/submitCodes")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse submitCodes(@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, "单据未扫码或扫码校验无法通过,提交失败,请检查后重新提交！");
        }
        ioAddInoutService.dealProcess(orderEntity);

        //不需要手动校验，则走正常单据校验处理流程
        if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
            ioCheckInoutService.check(orderEntity.getBillNo());
        }
        return ResultVOUtils.success("提交成功,等待处理！");
    }


    //新增业务单据，新增扫码单据，等待校验-草稿保存
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/saveOrderWeb")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse saveOrderWeb(@RequestBody AddOrderRequest addOrderRequest) {
        IoOrderEntity orderEntity = new IoOrderEntity();
        if (StrUtil.isEmpty(addOrderRequest.getAction()))
            return ResultVOUtils.error(500, "单据类型不能为空");
        orderEntity.setAction(addOrderRequest.getAction());
        BasicBussinessTypeEntity bussinessTypeEntity = basicBussinessTypeService.findByAction(addOrderRequest.getAction());
        orderEntity.setMainAction(bussinessTypeEntity.getMainAction());
        orderEntity.setFromCorp(addOrderRequest.getFromCorp());
        orderEntity.setRemark(addOrderRequest.getRemark());
        orderEntity.setFromInvCode(addOrderRequest.getFromInvCode());
        orderEntity.setDeptCode(addOrderRequest.getDeptCode());
        orderEntity.setBillNo(addOrderRequest.getBillNo());
        orderEntity.setInvCode(addOrderRequest.getInvCode());
        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("保存成功！");
    }

    //等待校验-立即提交
    @AuthRuleAnnotation("")
    @PostMapping("warehouse/inout/submitOrderWeb")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse submitOrderWeb(@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, "单据还未扫码或和扫码校验存在异常无法提交！");
        }

        if (checkInoutService.checkManual(addOrderRequest.getBillNo())) {
            if (CollUtil.isNotEmpty(orderDetailBizEntities)) {
                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(ConstantStatus.ORDER_STATUS_CHECK);
                orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_POST);
                orderService.update(orderEntity);
                checkInoutService.check(addOrderRequest.getBillNo());
            } else {
                return ResultVOUtils.error(500, "单据校验提交失败,请先录入业务单据！");
            }
        } else {
            ioAddInoutService.dealProcess(orderEntity);
            checkInoutService.check(addOrderRequest.getBillNo());
            return ResultVOUtils.success("提交成功！");
        }

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

    public BaseResponse checkSubmitEnable(IoOrderEntity orderEntity) {
        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("")
    @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.setId(null);
            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("提交成功！");
    }


    public void getSomeBiz(List<IoOrderDetailBizEntity> orderDetailBizEntities, IoOrderDetailBizEntity resutBizEntity) {
        for (IoOrderDetailBizEntity orderDetailBizEntity : orderDetailBizEntities) {
            if (orderDetailBizEntity.getBindRlFk().longValue() == resutBizEntity.getBindRlFk().longValue()) {
                resutBizEntity.setCertCode(orderDetailBizEntity.getCertCode());
                resutBizEntity.setPrice(orderDetailBizEntity.getPrice());
            }
        }
    }


    @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) {
            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);
        }
        return ResultVOUtils.success("删除成功！");
    }


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

    //已验收单据撤回
    @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, "撤回失败");

    }


    //已校验单据撤回到等待处理
    @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, "撤回失败");
    }


    //手持终端获取未处理业务单据进行校验
    @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.getEntrustEnd() == true) {
                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) {
        if (StrUtil.isBlank(billNo)) {
            return ResultVOUtils.error(ResultEnum.PARAM_VERIFY_FALL);
        }
        List<IoOrderEntity> list = orderService.filterOrderTrace(billNo);
        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
     */
    @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();
    }

    @PostMapping("/udiwms/inout/order/updateOrder")
    @Log(title = "单据管理", businessType = BusinessType.UPDATE)
    public BaseResponse updateOrder(@RequestBody IoOrderEntity ioOrderEntity) {
        ioOrderEntity.setUpdateTime(new Date());
        orderService.updateByBillNo(ioOrderEntity);
        return ResultVOUtils.success();
    }

    // --------------------------------------------------------UDI_MS平台--------------------------------------------------------------------------------------

    @ApiOperation("udims上传单据")
    @PostMapping("/warehouse/inout/postOrdersUdims")
    public BaseResponse postOrdersUdims(@RequestBody PostUdimsOrderRequest orderRequest) {

        ioAddInoutService.creatOrderByUdims(orderRequest);

        return ResultVOUtils.success();
    }

}