udi-wms-java/src/main/java/com/glxp/api/service/collect/IoCollectOrderService.java

package com.glxp.api.service.collect;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.IdUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.pagehelper.PageHelper;
import com.glxp.api.common.res.BaseResponse;
import com.glxp.api.common.util.ResultVOUtils;
import com.glxp.api.constant.Constant;
import com.glxp.api.constant.ConstantStatus;
import com.glxp.api.constant.ConstantType;
import com.glxp.api.dao.collect.IoCollectOrderMapper;
import com.glxp.api.dao.inout.IoCodeTempDao;
import com.glxp.api.entity.auth.SysWorkplace;
import com.glxp.api.entity.basic.*;
import com.glxp.api.entity.collect.*;
import com.glxp.api.entity.inout.IoCodeTempEntity;
import com.glxp.api.entity.inout.IoOrderDetailBizEntity;
import com.glxp.api.entity.inout.IoOrderEntity;
import com.glxp.api.entity.inout.IoSplitFifoInv;
import com.glxp.api.entity.inv.InvCountOrderDetailEntity;
import com.glxp.api.entity.inv.InvCountOrderEntity;
import com.glxp.api.entity.inv.InvCountSettingEntity;
import com.glxp.api.entity.thrsys.ThrSystemEntity;
import com.glxp.api.exception.JsonException;
import com.glxp.api.http.ErpBasicClient;
import com.glxp.api.http.HttpOkClient;
import com.glxp.api.req.basic.FilterUdiRelRequest;
import com.glxp.api.req.collect.CollectOrderBizRequest;
import com.glxp.api.req.collect.CollectOrderRequest;
import com.glxp.api.req.collect.PostCollectOrderRequest;
import com.glxp.api.req.inout.DeleteTageCodeRequest;
import com.glxp.api.req.inout.FilterOrderRequest;
import com.glxp.api.req.inout.PostOrderRequest;
import com.glxp.api.res.PageSimpleResponse;
import com.glxp.api.res.basic.BasicSkPrescribeResponse;
import com.glxp.api.res.basic.SysWorkplaceResponse;
import com.glxp.api.res.basic.UdiRelevanceResponse;
import com.glxp.api.res.collect.CollectOrderBizResponse;
import com.glxp.api.res.collect.IoCollectOrderResponse;
import com.glxp.api.res.inout.IoOrderResponse;
import com.glxp.api.res.thrsys.ThrInvProductResponse;
import com.glxp.api.service.auth.SysWorkplaceService;
import com.glxp.api.service.basic.*;
import com.glxp.api.service.inout.*;
import com.glxp.api.service.inout.impl.IoCodeService;
import com.glxp.api.util.*;
import com.glxp.api.util.udi.FilterUdiUtils;
import com.glxp.api.util.udi.UdiCalCountUtil;
import net.sf.jasperreports.engine.util.JRStyledText;
import org.springframework.beans.BeanUtils;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

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

@Service
public class IoCollectOrderService extends ServiceImpl<IoCollectOrderMapper, IoCollectOrder> {

    @Resource
    IoCollectOrderMapper collectOrderMapper;
    @Resource
    IoCollectOrderCodeManService ioCollectOrderCodeManService;
    @Resource
    IoOrderService orderService;
    @Resource
    IoOrderDetailBizService orderDetailBizService;
    @Resource
    IoCollectOrderBizService collectOrderBizService;
    @Resource
    UdiRelevanceService udiRelevanceService;
    @Resource
    BasicSkPrescribeService basicSkPrescribeService;
    @Resource
    BasicSkPrescirbeDetailService basicSkPrescirbeDetailService;
    @Resource
    IoOrderDetailBizService orderDetailCodeService;
    @Resource
    IoCodeTempService codeTempService;
    @Resource
    IoCodeService codeService;
    @Resource
    SysWorkplaceService sysWorkplaceService;
    @Resource
    SysWorkplaceDocumentService sysWorkplaceDocumentService;
    @Resource
    IoSplitFifoCodeService splitFifoCodeService;
    @Resource
    IoCollectOrderCodeAutoService collectOrderCodeAutoService;
    @Resource
    IoCollectOrderCodeManService collectOrderCodeManService;
    @Resource
    IoCollectCodeService collectCodeService;
    @Resource
    UdiCalCountUtil udiCalCountUtil;
    @Resource
    IBasicBussinessTypeService bussinessTypeService;
    @Resource
    private GennerOrderUtils gennerOrderUtils;
    @Resource
    private IoCodeTempDao codesTempDao;
    @Resource
    IoAddInoutService addInoutService;
    @Resource
    @Lazy
    IoCheckInoutService ioCheckInoutService;

    @Resource
    private ErpBasicClient erpBasicClient;
    @Resource
    IoSplitCodeService splitCodeService;
    @Resource
    IoCollectOrderOriginService collectOrderOriginService;
    @Resource
    IoCollectOrderBizOriginService collectOrderBizOriginService;

    @Resource
    IoCollectOrderBackupService ioCollectOrderBackupService;

    public IoCollectOrder getByBillNo(String billNo) {
        return collectOrderMapper.selectOne(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, billNo).last("limit 1"));
    }

    public IoCollectOrderResponse unionSearch(Long workPlaceCode, String busType, String unionKey) {
        CollectOrderRequest collectOrderRequest = new CollectOrderRequest();
        collectOrderRequest.setUnionKey(unionKey);
        collectOrderRequest.setWorkPlaceCode(workPlaceCode);
        collectOrderRequest.setBusType(busType);
        List<IoCollectOrderResponse> collectOrderResponses = filterList(collectOrderRequest);
        if (CollUtil.isNotEmpty(collectOrderResponses))
            return collectOrderResponses.get(0);
        else
            return null;
    }

    public int updateByBillNo(IoCollectOrder collectOrder) {
        return collectOrderMapper.update(collectOrder, new UpdateWrapper<IoCollectOrder>().eq("billNo", collectOrder.getBillNo()));
    }


    public List<IoCollectOrderResponse> filterList(CollectOrderRequest collectOrderRequest) {
        if (collectOrderRequest == null) {
            return Collections.emptyList();
        }
        if (collectOrderRequest.getPage() != null) {
            int offset = (collectOrderRequest.getPage() - 1) * collectOrderRequest.getLimit();
            PageHelper.offsetPage(offset, collectOrderRequest.getLimit());
        }
        List<IoCollectOrderResponse> data = collectOrderMapper.filterList(collectOrderRequest);
        return data;
    }


    public List<CollectOrderBizResponse> combieOrderDetail(CollectOrderBizRequest collectOrderBizRequest) {
        List<CollectOrderBizResponse> list = collectOrderBizService.filterList(collectOrderBizRequest);

        List<IoCollectOrderCodeAuto> splitCodes = collectOrderCodeAutoService.listByBillNo(collectOrderBizRequest.getOrderIdFk(), 1);
        List<IoCollectOrderCodeAuto> unSplitCodes = collectOrderCodeAutoService.listByBillNo(collectOrderBizRequest.getOrderIdFk(), 2);
        List<IoCollectOrderCodeMan> manList = collectOrderCodeManService.listByBillNo(collectOrderBizRequest.getOrderIdFk());

        List<CollectOrderBizResponse> collectOrderBizResponses = new ArrayList<>();
        for (CollectOrderBizResponse collectOrderBiz : list) {
            CollectOrderBizResponse collectOrderBizResponse = new CollectOrderBizResponse();
            BeanUtils.copyProperties(collectOrderBiz, collectOrderBizResponse);
            //拆零
            for (IoCollectOrderCodeAuto collectOrderCodeAuto : splitCodes) {
                if (IntUtil.value(collectOrderCodeAuto.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
                    collectOrderBizResponse.setSplitUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getSplitUdiCode()) + "," + collectOrderCodeAuto.getUdiCode());
                }
            }
            if (StrUtil.isNotEmpty(collectOrderBizResponse.getSplitUdiCode())) {
                collectOrderBizResponse.setSplitUdiCode(collectOrderBizResponse.getSplitUdiCode().substring(1));
            }
            //整取
            for (IoCollectOrderCodeAuto collectOrderCodeAuto : unSplitCodes) {
                if (IntUtil.value(collectOrderCodeAuto.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
                    collectOrderBizResponse.setUnSplitUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getUnSplitUdiCode()) + "," + collectOrderCodeAuto.getUdiCode());
                }
            }
            if (StrUtil.isNotEmpty(collectOrderBizResponse.getUnSplitUdiCode())) {
                collectOrderBizResponse.setUnSplitUdiCode(collectOrderBizResponse.getUnSplitUdiCode().substring(1));
            }
            //手动
            for (IoCollectOrderCodeMan collectOrderCodeMan : manList) {
                if (IntUtil.value(collectOrderCodeMan.getBizIdFk()) == IntUtil.value(collectOrderBiz.getId())) {
                    collectOrderBizResponse.setScanUdiCode(StrUtil.trimToEmpty(collectOrderBizResponse.getScanUdiCode()) + "," + collectOrderCodeMan.getUdiCode());
                }
            }
            if (StrUtil.isNotEmpty(collectOrderBizResponse.getScanUdiCode())) {
                collectOrderBizResponse.setScanUdiCode(collectOrderBizResponse.getScanUdiCode().substring(1));
            }

            if (StrUtil.isNotEmpty(collectOrderBizResponse.getReplaceCode())) {
                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getReplaceCode());
            } else if (StrUtil.isNotEmpty(collectOrderBizResponse.getScanUdiCode())) {
                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getScanUdiCode());
            } else if (StrUtil.isNotEmpty(collectOrderBizResponse.getSplitUdiCode())) {
                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getSplitUdiCode());
            } else if (StrUtil.isNotEmpty(collectOrderBizResponse.getUnSplitUdiCode())) {
                collectOrderBizResponse.setFinishUdiCode(collectOrderBizResponse.getUnSplitUdiCode());
            }

            collectOrderBizResponses.add(collectOrderBizResponse);
        }
        return collectOrderBizResponses;
    }


    /**
     * 导入内部数据
     */
    public void importOrder() {
        importUdi();
        importPrescribe(null);
    }

    public void clearOrder() {
        collectOrderMapper.clearOrder();
        List<IoOrderEntity> orderEntities = new ArrayList<>();
        List<IoOrderEntity> orderEntities1 = orderService.findAllByAction("SC72197936495755");
        List<IoOrderEntity> orderEntities2 = orderService.findAllByAction("SC72249388338364");
        orderEntities.addAll(orderEntities1);
        orderEntities.addAll(orderEntities2);
        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);
                    }
                }
        );
    }


    public void importUdi() {
        //下载UDI内部单据
        FilterOrderRequest filterOrderRequest = new FilterOrderRequest();
        filterOrderRequest.setStatus(7);
        filterOrderRequest.setProductType(null);
        List<IoOrderResponse> list = orderService.filterList(filterOrderRequest);
        List<IoCollectOrder> collectOrderList = new ArrayList<>();
        List<SysWorkplaceResponse> allWorksList = new ArrayList<>();
        for (IoOrderResponse ioOrderEntity : list) {

            if (collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, ioOrderEntity.getBillNo()))) {
                continue;
            }
            SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByBusType(ioOrderEntity.getAction());
            if (sysWorkplaceDocumentEntity == null)
                continue;
            List<SysWorkplaceResponse> sysWorkplaces = sysWorkplaceService.getAllByBusType(ioOrderEntity.getAction());

            //自动分配工位
            final Long[] defaultWorkplace = {null};
            if (CollUtil.isNotEmpty(sysWorkplaces)) {
                if (sysWorkplaces.size() == 1) {
                    defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
                } else {
                    List<SysWorkplaceResponse> addWorkplace = new ArrayList<>();
                    for (SysWorkplaceResponse sysWorkplace : sysWorkplaces) {
                        //获取是否有正在处理的工位
                        List<IoCollectOrder> collectOrderList1 = collectOrderMapper.selectList(new LambdaQueryWrapper<IoCollectOrder>()
                                .eq(IoCollectOrder::getWorkPlaceCode, sysWorkplace.getWorkplaceId()).in(IoCollectOrder::getTagStatus, -1, 1, 2));
                        sysWorkplace.setOrderCount(collectOrderList1.size());
                        if (IntUtil.value(sysWorkplace.getOrderCount()) > 0) {
                            addWorkplace.add(sysWorkplace);
                        }
                    }
                    if (addWorkplace.size() > 0) {
                        Optional<SysWorkplaceResponse> minCountObject = addWorkplace.stream()
                                .min((o1, o2) -> Integer.compare(o1.getOrderCount(), o2.getOrderCount()));
                        minCountObject.ifPresent(sysWorkplace -> defaultWorkplace[0] = sysWorkplace.getWorkplaceId());
                    } else {
                        defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
                    }
                }
            }
            IoCollectOrder collectOrder = IoCollectOrder.builder()
                    .billNo(ioOrderEntity.getBillNo())
                    .fromType("UDI系统")
                    .busType(ioOrderEntity.getAction())
                    .fromCorp(ioOrderEntity.getFromName())
                    .workPlaceCode(defaultWorkplace[0])
                    .billTime(ioOrderEntity.getCreateTime())
                    .createTime(ioOrderEntity.getCreateTime())
                    .createUser(ioOrderEntity.getCreateUser())
                    .updateTime(new Date())
                    .orderCirType(sysWorkplaceDocumentEntity.getOrderCirType())
                    .splitStatus(0)
                    .tagStatus(0)
                    .build();
            if (collectOrder.getWorkPlaceCode() != null) {
                collectOrder.setTagStatus(1);
            }
            save(collectOrder);
            List<IoOrderDetailBizEntity> orderDetailBizEntities = orderDetailBizService.findByOrderId(ioOrderEntity.getBillNo());

            List<IoCollectOrderBiz> collectOrderBizs = new ArrayList<>();
            for (IoOrderDetailBizEntity bizEntity : orderDetailBizEntities) {
                UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByRelId(bizEntity.getBindRlFk() + "");
                IoCollectOrderBiz collectOrderBiz = IoCollectOrderBiz.builder().orderIdFk(collectOrder.getBillNo())
                        .relId(bizEntity.getBindRlFk())
                        .thrCode(udiRelevanceResponse.getMainId())
                        .ybbm(udiRelevanceResponse.getYbbm())
                        .payFeeCode(udiRelevanceResponse.getPayFeeCode())
                        .cpmctymc(bizEntity.getCoName())
                        .nameCode(bizEntity.getNameCode())
                        .ggxh(bizEntity.getSpec())
                        .batchNo(bizEntity.getBatchNo())
                        .productDate(bizEntity.getProductDate())
                        .expireDate(bizEntity.getExpireDate())
                        .count(bizEntity.getCount())
                        .measureUnit(bizEntity.getMeasname())
                        .tagStatus(1)
                        .unTagCount(bizEntity.getCount()).build();

                if (IntUtil.value(udiRelevanceResponse.getProductsType()) == 2) {
                    collectOrderBiz.setGgxh(udiRelevanceResponse.getBzgg());
                    collectOrderBiz.setMeasureUnit(udiRelevanceResponse.getPrepnUnit());
                }
                collectOrderBizs.add(collectOrderBiz);
            }
            if (CollUtil.isNotEmpty(collectOrderBizs)) {
                collectOrderBizService.saveBatch(collectOrderBizs);
            }
            allWorksList.addAll(sysWorkplaces);

            if (IntUtil.value(sysWorkplaceDocumentEntity.getAutoTag()) == 1 && IntUtil.value(collectOrder.getTagStatus()) == 1) {
                splitFifoCodeService.lockInventoryByOrder(collectOrder.getBillNo(), 1);
            }

        }
//        if (CollUtil.isNotEmpty(collectOrderList)) {
//            saveBatch(collectOrderList);
//        }

//        Map<Long, SysWorkplaceResponse> sysWorkplaceMap = new HashMap<>();
//        for (SysWorkplaceResponse sysWorkplace : allWorksList) {
//            sysWorkplaceMap.put(sysWorkplace.getId(), sysWorkplace);
//        }
//        for (SysWorkplaceResponse value : sysWorkplaceMap.values()) {
//            splitFifoCodeService.preAllotInv(value.getWorkplaceId());
//        }

    }


    public void importPrescribe(List<BasicSkPrescribeEntity> basicSkPrescribeEntities) {
        //下载处方
        if (CollUtil.isEmpty(basicSkPrescribeEntities))
            basicSkPrescribeEntities = basicSkPrescribeService.list();
        List<SysWorkplaceResponse> allWorksList = new ArrayList<>();
        for (BasicSkPrescribeEntity basicSkPrescribeEntity : basicSkPrescribeEntities) {
            if (collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, basicSkPrescribeEntity.getCode()))) {
                continue;
            }
            SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByBusType(basicSkPrescribeEntity.getAddr());
            if (sysWorkplaceDocumentEntity == null)
                continue;
            //自动分配工位
            final Long[] defaultWorkplace = {null};
            List<SysWorkplaceResponse> sysWorkplaces = sysWorkplaceService.getAllByBusType(basicSkPrescribeEntity.getAddr());
            if (CollUtil.isNotEmpty(sysWorkplaces)) {
                if (sysWorkplaces.size() == 1) {
                    defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
                } else {
                    List<SysWorkplaceResponse> addWorkplace = new ArrayList<>();
                    for (SysWorkplaceResponse sysWorkplace : sysWorkplaces) {
                        //获取是否有正在处理的工位
                        List<IoCollectOrder> collectOrderList1 = collectOrderMapper.selectList(new LambdaQueryWrapper<IoCollectOrder>()
                                .eq(IoCollectOrder::getWorkPlaceCode, sysWorkplace.getWorkplaceId()).in(IoCollectOrder::getTagStatus, -1, 1, 2));
                        sysWorkplace.setOrderCount(collectOrderList1.size());
                        if (IntUtil.value(sysWorkplace.getOrderCount()) > 0) {
                            addWorkplace.add(sysWorkplace);
                        }
                    }
                    if (addWorkplace.size() > 0) {
                        Optional<SysWorkplaceResponse> minCountObject = addWorkplace.stream()
                                .min((o1, o2) -> Integer.compare(o1.getOrderCount(), o2.getOrderCount()));
                        minCountObject.ifPresent(sysWorkplace -> defaultWorkplace[0] = sysWorkplace.getWorkplaceId());
                    } else {
                        defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
                    }
                }
            }


            IoCollectOrder collectOrder = IoCollectOrder.builder()
                    .billNo(basicSkPrescribeEntity.getCode())
                    .busType(sysWorkplaceDocumentEntity.getDocumentTypeCode())
                    .fromType("HIS系统")
                    .fromCorp(basicSkPrescribeEntity.getSickerCode())
                    .workPlaceCode(defaultWorkplace[0])
                    .billTime(MsDateUtil.localToDate(basicSkPrescribeEntity.getPrescribeDate()))
                    .createTime(new Date())
                    .createUser(basicSkPrescribeEntity.getCreateUser())
                    .backupOrderRemark1(basicSkPrescribeEntity.getStooutNo())
                    .updateTime(new Date())
                    .orderCirType(sysWorkplaceDocumentEntity.getOrderCirType())
                    .splitStatus(0)
                    .tagStatus(0)
                    .build();
            if (collectOrder.getWorkPlaceCode() != null) {
                collectOrder.setTagStatus(1);
            }
            save(collectOrder);
            List<BasicSkPrescribeItemEntity> basicSkPrescribeItemEntities = basicSkPrescirbeDetailService.findByPrescribeNum(basicSkPrescribeEntity.getCode());
            List<IoCollectOrderBiz> collectOrderBizs = new ArrayList<>();
            for (BasicSkPrescribeItemEntity bizEntity : basicSkPrescribeItemEntities) {
                UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByRelId(bizEntity.getRelId() + "");
                double doubleValue = Double.parseDouble(bizEntity.getMeasureCount());
                IoCollectOrderBiz collectOrderBiz = IoCollectOrderBiz.builder().orderIdFk(collectOrder.getBillNo())
                        .relId(bizEntity.getRelId())
                        .thrCode(bizEntity.getItemCode())
                        .ybbm(udiRelevanceResponse.getYbbm())
                        .payFeeCode(udiRelevanceResponse.getPayFeeCode())
                        .cpmctymc(bizEntity.getItemName())
                        .nameCode(udiRelevanceResponse.getNameCode())
                        .batchNo(bizEntity.getBatchNo())
                        .count((int) doubleValue)
                        .measureUnit(bizEntity.getMeasureUnit())
                        .tagStatus(1)
                        .unTagCount(bizEntity.getCount()).build();

                if (IntUtil.value(udiRelevanceResponse.getProductsType()) == 2) {
                    collectOrderBiz.setMeasureUnit(udiRelevanceResponse.getPrepnUnit());
                }
                collectOrderBizs.add(collectOrderBiz);
            }
            if (CollUtil.isNotEmpty(collectOrderBizs))
                collectOrderBizService.saveBatch(collectOrderBizs);

            allWorksList.addAll(sysWorkplaces);
            if (IntUtil.value(sysWorkplaceDocumentEntity.getAutoTag()) == 1 && IntUtil.value(collectOrder.getTagStatus()) == 1) {
                splitFifoCodeService.lockInventoryByOrder(collectOrder.getBillNo(), 1);
            }

        }
    }


    /**
     * 单据回填
     *
     * @param ioCollectOrderList
     * @param addr
     */
    @Transactional(rollbackFor = Exception.class)
    public void importPrescribe(List<IoCollectOrder> ioCollectOrderList, String addr) {
        //下载处方
        if (CollUtil.isNotEmpty(ioCollectOrderList)) {
            for (IoCollectOrder collectOrder : ioCollectOrderList) {
                IoCollectOrderOrigin ioCollectOrderOrigin = new IoCollectOrderOrigin();

                if (collectOrderMapper.exists(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, collectOrder.getBillNo()))) {
                    continue;
                }
                SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByBusType(addr);
                if (sysWorkplaceDocumentEntity == null) {
                    continue;
                }
                if (collectOrder.getWorkPlaceCode() == null) {
                    //自动分配工位
                    final Long[] defaultWorkplace = {null};
                    List<SysWorkplaceResponse> sysWorkplaces = sysWorkplaceService.getAllByBusType(addr);
                    if (CollUtil.isNotEmpty(sysWorkplaces)) {
                        if (sysWorkplaces.size() == 1) {
                            defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
                        } else {
                            List<SysWorkplaceResponse> addWorkplace = new ArrayList<>();
                            for (SysWorkplaceResponse sysWorkplace : sysWorkplaces) {
                                //获取是否有正在处理的工位
                                List<IoCollectOrder> collectOrderList1 = collectOrderMapper.selectList(new LambdaQueryWrapper<IoCollectOrder>()
                                        .eq(IoCollectOrder::getWorkPlaceCode, sysWorkplace.getWorkplaceId()).in(IoCollectOrder::getTagStatus, -1, 1, 2));
                                sysWorkplace.setOrderCount(collectOrderList1.size());
                                if (IntUtil.value(sysWorkplace.getOrderCount()) > 0) {
                                    addWorkplace.add(sysWorkplace);
                                }
                            }
                            if (addWorkplace.size() > 0) {
                                Optional<SysWorkplaceResponse> minCountObject = addWorkplace.stream()
                                        .min((o1, o2) -> Integer.compare(o1.getOrderCount(), o2.getOrderCount()));
                                minCountObject.ifPresent(sysWorkplace -> defaultWorkplace[0] = sysWorkplace.getWorkplaceId());
                            } else {
                                defaultWorkplace[0] = sysWorkplaces.get(0).getWorkplaceId();
                            }
                        }
                    }
                    collectOrder.setWorkPlaceCode(defaultWorkplace[0]);
                }

                collectOrder.setBusType(sysWorkplaceDocumentEntity.getDocumentTypeCode());
                collectOrder.setOrderCirType(sysWorkplaceDocumentEntity.getOrderCirType());
                BeanUtils.copyProperties(collectOrder,ioCollectOrderOrigin);

                if (!collectOrder.getTagStatus().equals(4) && collectOrder.getWorkPlaceCode() != null) {
                    collectOrder.setTagStatus(1);
                    this.save(collectOrder);
                }
                collectOrderOriginService.save(ioCollectOrderOrigin);

                List<IoCollectOrderBiz> bizList = collectOrder.getBizList();
                if (CollUtil.isNotEmpty(bizList)) {
                    for (IoCollectOrderBiz collectOrderBiz : bizList) {
                        if (collectOrderBiz.getRelId() != null) {
                            UdiRelevanceResponse udiRelevanceResponse = udiRelevanceService.selectByRelId(collectOrderBiz.getRelId() + "");
                            if (udiRelevanceResponse != null) {
                                collectOrderBiz.setYbbm(udiRelevanceResponse.getYbbm());
                                collectOrderBiz.setPayFeeCode(udiRelevanceResponse.getPayFeeCode());
                                collectOrderBiz.setNameCode(udiRelevanceResponse.getNameCode());
                                if (IntUtil.value(udiRelevanceResponse.getProductsType()) == 2) {
                                    collectOrderBiz.setMeasureUnit(udiRelevanceResponse.getPrepnUnit());
                                }
                            }
                        }
                    }
                    collectOrderBizService.saveBatch(bizList);
                    List<IoCollectOrderBizOrigin> ioCollectOrderBizOrigins = BeanCopyUtils.copyList(bizList, IoCollectOrderBizOrigin.class);
                    collectOrderBizOriginService.saveBatch(ioCollectOrderBizOrigins);
                }
                if (IntUtil.value(sysWorkplaceDocumentEntity.getAutoTag()) == 1 && IntUtil.value(collectOrder.getTagStatus()) == 1) {
                    splitFifoCodeService.lockInventoryByOrder(collectOrder.getBillNo(), 1);
                }
            }
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public void removeCode(DeleteTageCodeRequest deleteTageCodeRequest) {
        Integer delType = deleteTageCodeRequest.getDelType();
        Long codeManId = deleteTageCodeRequest.getCodeManId();
        IoCollectOrderCodeMan ioCollectOrderCodeMan = ioCollectOrderCodeManService.getById(codeManId);
        if (ioCollectOrderCodeMan == null) throw new JsonException("码明细id有误");
        Long bizIdFk = ioCollectOrderCodeMan.getBizIdFk();
        Integer scanCount = ioCollectOrderCodeMan.getScanCount();
        Integer delCount = 0;
        if (delType == 1) {//1.减一，，，IoCollectOrderCodeMan-1    IoCollectOrderBiz-1
            Integer newCount = scanCount - 1;
            delCount = 1;
            if (newCount == 0) {
                ioCollectOrderCodeManService.removeById(codeManId);
            } else {
                ioCollectOrderCodeMan.setScanCount(newCount);
                ioCollectOrderCodeManService.updateById(ioCollectOrderCodeMan);
            }
        } else if (delType == 2) {//2.删除     IoCollectOrderCodeMan-删除    IoCollectOrderBiz-数量
            delCount = scanCount;
            ioCollectOrderCodeManService.removeById(codeManId);
        }

        if (delCount > 0) {
            IoCollectOrderBiz bizServiceOne = collectOrderBizService.getOne(new LambdaQueryWrapper<IoCollectOrderBiz>()
                    .eq(IoCollectOrderBiz::getId, bizIdFk));
            if (bizServiceOne == null) throw new JsonException("扫码详情未查找到");
            //反查单据类型 查看是否来源业务单
            String orderIdFk = bizServiceOne.getOrderIdFk();
            IoCollectOrder ioCollectOrder = collectOrderMapper.selectOne(new LambdaQueryWrapper<IoCollectOrder>().eq(IoCollectOrder::getBillNo, orderIdFk));
            if (ioCollectOrder == null) throw new JsonException("反查单据失败");
            String busType = ioCollectOrder.getBusType();
            Long workPlaceCode = ioCollectOrder.getWorkPlaceCode();
            SysWorkplaceDocumentEntity byWorkplaceCode = sysWorkplaceDocumentService.findByWorkplaceCode(workPlaceCode, busType);
            if (byWorkplaceCode == null) throw new JsonException("反查工位单据类型失败");
            Integer scanType = byWorkplaceCode.getScanType();
            Integer oneScanCount = bizServiceOne.getScanCount();
            Integer newCount = oneScanCount - delCount;
            if (scanType == 1 && newCount <= 0) {
                collectOrderBizService.removeById(bizServiceOne);
            } else {
                bizServiceOne.setScanCount(newCount);

                List<UdiRelevanceResponse> udiRelevanceResponses = udiRelevanceService.selectGroupByNameCode(bizServiceOne.getNameCode(), null);
                if (IntUtil.value(byWorkplaceCode.getOrderCirType()) == 1) {
                    bizServiceOne.setScanActCount(IntUtil.value(bizServiceOne.getScanActCount()) - delCount * udiCalCountUtil.getCirActCount(udiRelevanceResponses.get(0)));
                } else {
                    bizServiceOne.setScanActCount(IntUtil.value(bizServiceOne.getScanActCount()) - delCount * udiCalCountUtil.getUseActCount(udiRelevanceResponses.get(0)));
                }

                collectOrderBizService.updateById(bizServiceOne);
            }
        }

    }

    /**
     * 更新排序时间
     *
     * @param collectOrderRequest
     */
    @Transactional(rollbackFor = Exception.class)
    public void orderTop(CollectOrderRequest collectOrderRequest) {
        Assert.notNull(collectOrderRequest.getId(), "id不能为空");
        IoCollectOrder old = this.getById(collectOrderRequest.getId());
        Assert.notNull(old, "不存在该库存预警设置");
        this.lambdaUpdate()
                .set(IoCollectOrder::getUpdateTime, new Date())
                .set(collectOrderRequest.getUpdateUser() != null, IoCollectOrder::getUpdateUser, collectOrderRequest.getUpdateUser())
                .set(IoCollectOrder::getOrderTime, new Date())
                .eq(IoCollectOrder::getId, collectOrderRequest.getId()).update();
    }

    public void finishOrder(CollectOrderRequest collectOrderRequest) {
        IoCollectOrder collectOrder = new IoCollectOrder();
        BeanUtils.copyProperties(collectOrderRequest, collectOrder);
        collectOrder.setTagStatus(3);
        collectOrder.setUpdateTime(new Date());
        updateByBillNo(collectOrder);
        splitCodeService.finishAutoTagCode(collectOrder);
        //插入备用表
        IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
        BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
        ioCollectOrderBackupService.save(ioCollectOrderBackup);
        ThreadUtil.execAsync(() -> {
            //插入到码表
            collectCodeService.insertCodesByBill(collectOrderRequest.getBillNo());
            //更新数据至第三方系统
        });
    }



    @Resource
    IoCollectOrderBizBackupService ioCollectOrderBizBackupService;
    /**
     * @param billNo
     */
//    @Transactional(rollbackFor = Exception.class)
//    public void generateOrder(String billNo) {
//
//        IoCollectOrder collectOrder = getByBillNo(billNo);
//        SysWorkplaceDocumentEntity sysWorkplaceDocumentEntity = sysWorkplaceDocumentService.findByWorkplaceCode(collectOrder.getWorkPlaceCode(), collectOrder.getBusType());
//        //1.内部系统，且单据为扫码生成业务单则创建系统单据
//        if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() == 1) {
//            List<IoCollectOrderCodeMan> collectOrderCodes = collectOrderCodeManService.listByBillNo(collectOrder.getBillNo());
//            BasicBussinessTypeEntity bussinessTypeEntity;
//            sysWorkplaceDocumentEntity.getInoutType();
//
//            //构造单据数据
//            IoOrderEntity orderEntity = new IoOrderEntity();
//            bussinessTypeEntity = bussinessTypeService.findByAction(sysWorkplaceDocumentEntity.getDocumentTypeCode());
//            orderEntity.setMainAction(bussinessTypeEntity.getMainAction());
//            orderEntity.setAction(bussinessTypeEntity.getAction());
//            orderEntity.setCreateTime(new Date());
//            orderEntity.setInvCode(sysWorkplaceDocumentEntity.getInvCode() + "");
//            orderEntity.setDeptCode("");
//            orderEntity.setFromCorp(collectOrder.getFromCorp());
//            orderEntity.setCorpOrderId(CustomUtil.getId() + "x");
//            orderEntity.setExportStatus(0);
//            orderEntity.setStatus(ConstantStatus.ORDER_STATUS_CHECK_PROCESS);
//            orderEntity.setDealStatus(ConstantStatus.ORDER_DEAL_DRAFT);
//            orderEntity.setCreateUser(collectOrder.getCreateUser());
//            orderEntity.setCreateTime(new Date());
//            orderEntity.setUpdateUser(collectOrder.getCreateUser());
//            orderEntity.setUpdateTime(new Date());
//            orderEntity.setCustomerId("110");
//            orderEntity.setOrderType(2);
//            orderEntity.setFromType(2);
//            String orderNo = gennerOrderUtils.createScOrderNo(new OrderNoTypeBean(Constant.SCAN_ORDER + StrUtil.trimToEmpty(bussinessTypeEntity.getPrefix()), "yyyyMMdd"));
//            orderEntity.setBillNo(orderNo);
//            List<IoCodeTempEntity> lossCodesList = new ArrayList<>();
//
//            for (IoCollectOrderCodeMan collectOrderCodeMan : collectOrderCodes) {
//                lossCodesList.add(buildCodeEntity(collectOrderCodeMan, orderEntity));
//            }
//            orderService.insertOrder(orderEntity);
//            codesTempDao.insertBatch(lossCodesList);
//            addInoutService.dealProcess(orderEntity);
//            if (!ioCheckInoutService.checkManual(orderEntity.getBillNo())) {
//                ioCheckInoutService.check(orderEntity.getBillNo());
//            }
//        } else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 1 && sysWorkplaceDocumentEntity.getScanType() != 1) {
//            //更新单据为已完成
//            IoOrderEntity orderEntity = orderService.findByBillNo(collectOrder.getBillNo());
//            orderEntity.setStatus(7);
//            orderService.update(orderEntity);
//        } else if (IntUtil.value(sysWorkplaceDocumentEntity.getIsMatching()) == 0) {
//            //todo  根据单据类型上传医保或者第三方系统
//            PostCollectOrderRequest orderRequest = new PostCollectOrderRequest();
//            orderRequest.setThirdSys("thirdId");
//            CollectOrderBizRequest collectOrderBizRequest = new CollectOrderBizRequest();
//            collectOrderBizRequest.setOrderIdFk(collectOrder.getBillNo());
//            List<CollectOrderBizResponse> collectOrderBizResponses = combieOrderDetail(collectOrderBizRequest);
//            collectOrder.setCollectOrderBizResponseList(collectOrderBizResponses);
//            List<IoCollectOrder> collectOrderList = new ArrayList<>();
//            collectOrderList.add(collectOrder);
//            orderRequest.setCollectOrderList(collectOrderList);
//            BaseResponse<BasicSkPrescribeResponse> baseResponse = erpBasicClient.postOrder(orderRequest);
//            log.debug("单据返回=========" + baseResponse);
//            if (baseResponse.getCode() == 20000) {
//                //
//            } else {
//                throw new JsonException("连接第三方系统接口服务出错，" + baseResponse.getMessage());
//            }
//
//        }
//        //插入处方备份表
//        IoCollectOrderBackup ioCollectOrderBackup = new IoCollectOrderBackup();
//        BeanUtils.copyProperties(collectOrder, ioCollectOrderBackup);
//        boolean save = ioCollectOrderBackupService.save(ioCollectOrderBackup);
//        if (!save){
//            throw new JsonException(500,"处方备用上传失败");
//        }
//        List<IoCollectOrderBiz> ioCollectOrderBizs = collectOrderBizService.listByBillNo(collectOrder.getBillNo());
//        for (IoCollectOrderBiz ioCollectOrderBiz : ioCollectOrderBizs){
//            IoCollectOrderBizBackup ioCollectOrderBizBackup = new IoCollectOrderBizBackup();
//            BeanUtils.copyProperties(ioCollectOrderBiz, ioCollectOrderBizBackup);
//            boolean save1 = ioCollectOrderBizBackupService.save(ioCollectOrderBizBackup);
//            if (!save1){
//                throw new JsonException(500,"处方备用明细上传失败");
//            }
//        }
//
//
//    }

    @Resource
    UdiRlSupService udiRlSupService;

    private IoCodeTempEntity buildCodeEntity(IoCollectOrderCodeMan collectOrderCodeMan, IoOrderEntity orderEntity) {
        IoCodeTempEntity tempEntity = new IoCodeTempEntity();
        tempEntity.setOrderId(orderEntity.getBillNo());
        tempEntity.setCode(collectOrderCodeMan.getUdiCode());
        tempEntity.setRelId(collectOrderCodeMan.getRelId());
        tempEntity.setMainAction(orderEntity.getMainAction());
        tempEntity.setInvCode(orderEntity.getInvCode());
        tempEntity.setBatchNo(collectOrderCodeMan.getBatchNo());
        tempEntity.setProduceDate(collectOrderCodeMan.getProductDate());
        tempEntity.setExpireDate(collectOrderCodeMan.getExpireDate());
        tempEntity.setSerialNo(collectOrderCodeMan.getSerialNo());
        tempEntity.setNameCode(collectOrderCodeMan.getNameCode());
        tempEntity.setCount(collectOrderCodeMan.getScanCount());
        tempEntity.setReCount(collectOrderCodeMan.getScanCount());
        tempEntity.setCreateTime(new Date());
        tempEntity.setUpdateTime(new Date());
        CompanyProductRelevanceEntity udiRlSupEntity = udiRlSupService.selOneByRlId(tempEntity.getRelId());
        if (udiRlSupEntity != null)
            tempEntity.setSupId(udiRlSupEntity.getCustomerId());
        tempEntity.setDeptCode(orderEntity.getDeptCode());
        return tempEntity;
    }

    /**
     * 上传更新状态
     *
     * @param billNo
     */
    @Transactional(rollbackFor = Exception.class)
    public void orderUpload(String billNo) {
        IoCollectOrder updateOrder = new IoCollectOrder();
        updateOrder.setBillNo(billNo);
        try {
//            this.generateOrder(billNo);
            updateOrder.setUploadStatus(2);
        } catch (Exception e) {
            updateOrder.setUploadStatus(3);
            updateOrder.setUploadError(e.getMessage());
        }
        //更新状态
        this.updateByBillNo(updateOrder);
    }


}