代码优化

skyouc

18 小时以前 ebdfa825c07189b5f8e89f147d96d1bc612589db

代码优化

 rsf-server/src/main/java/com/vincent/rsf/server/api/controller/params/PublicToStockParams.java

@@ -1,8 +1,6 @@
package com.vincent.rsf.server.api.controller.params;

import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WaitPakin;
import com.vincent.rsf.server.manager.entity.WaitPakinItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
@@ -19,6 +17,6 @@
    private String locCode;

    @ApiModelProperty("单据明细")
    private List<AsnOrderItem> itemList;
    private List<WkOrderItem> itemList;

}

 rsf-server/src/main/java/com/vincent/rsf/server/api/entity/dto/ContainerWaveDto.java

@@ -1,6 +1,6 @@
package com.vincent.rsf.server.api.entity.dto;

import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.TaskItem;
import io.swagger.annotations.ApiModel;
import lombok.Data;
@@ -14,6 +14,6 @@
public class ContainerWaveDto {

    private TaskItem taskItem;
    private List<AsnOrderItem> asnOrderItems;
    private List<WkOrderItem> wkOrderItems;

}

 rsf-server/src/main/java/com/vincent/rsf/server/api/entity/dto/OperateStockDto.java

@@ -1,8 +1,8 @@
package com.vincent.rsf.server.api.entity.dto;

import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;

public class OperateStockDto extends AsnOrderItem {
public class OperateStockDto extends WkOrderItem {


}

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/MobileServiceImpl.java

@@ -176,14 +176,14 @@
        if (StringUtils.isBlank(barcode)) {
            return R.error("标签码不能为空！！");
        }
        List<AsnOrderItem> asnOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getTrackCode, barcode));
        List<WkOrderItem> wkOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getTrackCode, barcode));

        if (Objects.isNull(asnOrderItem)) {
        if (Objects.isNull(wkOrderItem)) {
            throw new CoolException("单据明细不存在！！");
        }
        List<AsnOrderItem> items = new ArrayList<>();
        for (AsnOrderItem record : asnOrderItem) {
        List<WkOrderItem> items = new ArrayList<>();
        for (WkOrderItem record : wkOrderItem) {
            if (!Objects.isNull(record.getFieldsIndex())) {
                Map<String, String> fields = FieldsUtils.getFields(record.getFieldsIndex());
                record.setExtendFields(fields);
@@ -269,7 +269,7 @@
//                    .eq(AsnOrderItem::getTrackCode, dto.getBarcode())
//                    .eq(AsnOrderItem::getSplrBatch, dto.getSplrBatch()));

            AsnOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getId, dto.getId()));
            WkOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getId, dto.getId()));
            //asnOrderItemMapper.resultById(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getId, dto.getId()));

            if (Objects.isNull(orderItem)) {
@@ -348,7 +348,7 @@
        return R.ok("收货成功！！");
    }

    private void extracted(Long loginUserId, ReceiptDetlsDto dto, WarehouseAreas areasItem, AsnOrderItem orderItem, WkOrder wkOrder, Matnr matnr) {
    private void extracted(Long loginUserId, ReceiptDetlsDto dto, WarehouseAreas areasItem, WkOrderItem orderItem, WkOrder wkOrder, Matnr matnr) {

        Companys companys = new Companys();
        if (StringUtils.isNoneBlank(orderItem.getSplrCode())) {
@@ -452,18 +452,18 @@
            throw new CoolException("请检查订单状态是否已完成或已取消！！");
        }

        List<AsnOrderItem> asnOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnCode, params.getAsnCode())
                .eq(!Objects.isNull(params.getTrackCode()), AsnOrderItem::getTrackCode, params.getTrackCode())
                .eq(!Cools.isEmpty(params.getMatnrCode()), AsnOrderItem::getMatnrCode, params.getMatnrCode())
        List<WkOrderItem> wkOrderItem = asnOrderItemMapper.selectList(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getAsnCode, params.getAsnCode())
                .eq(!Objects.isNull(params.getTrackCode()), WkOrderItem::getTrackCode, params.getTrackCode())
                .eq(!Cools.isEmpty(params.getMatnrCode()), WkOrderItem::getMatnrCode, params.getMatnrCode())
        );

        if (Objects.isNull(asnOrderItem)) {
        if (Objects.isNull(wkOrderItem)) {
            throw new CoolException("单据明细不存在！！");
        }

        List<AsnOrderItem> items = new ArrayList<>();
        for (AsnOrderItem record : asnOrderItem) {
        List<WkOrderItem> items = new ArrayList<>();
        for (WkOrderItem record : wkOrderItem) {
            if (!Objects.isNull(record.getFieldsIndex())) {
                Map<String, String> fields = FieldsUtils.getFields(record.getFieldsIndex());
                record.setExtendFields(fields);
@@ -578,7 +578,7 @@
        }
        InspectDetlDto detlDto = new InspectDetlDto();
        detlDto.setCode(wkOrders.getCode()).setId(wkOrders.getId()).setPoCode(wkOrders.getPoCode());
        List<AsnOrderItem> orderItems = asnOrderItemMapper.selectList(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnCode, code));
        List<WkOrderItem> orderItems = asnOrderItemMapper.selectList(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnCode, code));
        if (orderItems.isEmpty()) {
            detlDto.setItems(new ArrayList<>());
        } else {
@@ -761,8 +761,8 @@
        if (StringUtils.isBlank(ruleCode)) {
            throw new CoolException("当前业务：" + SerialRuleCode.SYS_STOCK_CODE + "，编码规则不存在！！");
        }
        List<AsnOrderItem> itemList = params.getItemList();
        double sum = itemList.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
        List<WkOrderItem> itemList = params.getItemList();
        double sum = itemList.stream().mapToDouble(WkOrderItem::getAnfme).sum();
        stock.setAnfme(sum)
                .setSourceId(order.getId())
                .setType(order.getType())
@@ -978,7 +978,7 @@
     */
    @Override
    public R defectProducts(String trackCode) {
        AsnOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getTrackCode, trackCode));
        WkOrderItem orderItem = asnOrderItemMapper.selectOne(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getTrackCode, trackCode));
        return R.ok(orderItem);
    }

@@ -1050,7 +1050,7 @@
    /**
     * 获取ReceiptDetlsDtos
     */
    private R getAsnOrderItem(List<AsnOrderItem> items) {
    private R getAsnOrderItem(List<WkOrderItem> items) {
        List<ReceiptDetlsDto> detlsDtos = new ArrayList<>();
        items.forEach(asnOrderItem -> {
            ReceiptDetlsDto detlsDto = new ReceiptDetlsDto();

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/PdaOutStockServiceImpl.java

@@ -71,7 +71,7 @@
        List<TaskItem> taskItems = taskItemService.list(new LambdaQueryWrapper<TaskItem>().eq(TaskItem::getTaskId, task.getId()));
        Map<Long, List<TaskItem>> maps = taskItems.stream().collect(Collectors.groupingBy(TaskItem::getSource));
        maps.keySet().forEach(key -> {
                AsnOrderItem orderItem = asnOrderItemService.getById(key);
                WkOrderItem orderItem = asnOrderItemService.getById(key);
                if (Objects.isNull(orderItem)) {
                    throw new CoolException("单据明细不存在！！");
                }
@@ -120,13 +120,13 @@
                throw new CoolException("波次对应关联单未找到");
            }
            List<Long> ids = waveOrderRelas.stream().map(WaveOrderRela::getOrderId).collect(Collectors.toList());
            ArrayList<AsnOrderItem> list = new ArrayList<>();
            ArrayList<WkOrderItem> list = new ArrayList<>();
            List<WkOrder> wkOrderList = asnOrderService.list(new LambdaQueryWrapper<WkOrder>().in(WkOrder::getId, ids));
            for (WkOrder wkOrder : wkOrderList) {
                AsnOrderItem orderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<AsnOrderItem>()
                        .eq(AsnOrderItem::getAsnId, wkOrder.getId())
                        .eq(AsnOrderItem::getMatnrCode, taskItem.getMatnrCode())
                        .eq(AsnOrderItem::getSplrBatch, taskItem.getBatch())
                WkOrderItem orderItem = asnOrderItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
                        .eq(WkOrderItem::getAsnId, wkOrder.getId())
                        .eq(WkOrderItem::getMatnrCode, taskItem.getMatnrCode())
                        .eq(WkOrderItem::getSplrBatch, taskItem.getBatch())
                );
                if (null != orderItem){
                    list.add(orderItem);
@@ -134,7 +134,7 @@


            }
            containerWaveDto.setAsnOrderItems(list);
            containerWaveDto.setWkOrderItems(list);
            containerWaveDtos.add(containerWaveDto);
        }

@@ -158,17 +158,17 @@

        for (ContainerWaveDto containerWaveDto : containerWaveParam.getContainerWaveDtos()) {
            //做一次校验，判断前端所有出库数量是否超过本托出库数量
            double sum = containerWaveDto.getAsnOrderItems().stream().mapToDouble(AsnOrderItem::getDemandQty).sum();
            double sum = containerWaveDto.getWkOrderItems().stream().mapToDouble(WkOrderItem::getDemandQty).sum();
            BigDecimal total = new BigDecimal(String.valueOf(sum));
            BigDecimal anfme = new BigDecimal(containerWaveDto.getTaskItem().getAnfme().toString());
            if (!anfme.equals(total)){
                throw new CoolException("播种数量不等于容器出库数量，请检查");
            }
            for (AsnOrderItem oldOrderItem : containerWaveDto.getAsnOrderItems()) {
            for (WkOrderItem oldOrderItem : containerWaveDto.getWkOrderItems()) {
                if (Double.compare(oldOrderItem.getDemandQty(), 0.0) == 0) {
                    continue;
                }
                AsnOrderItem orderItem = asnOrderItemService.getById(oldOrderItem.getId());
                WkOrderItem orderItem = asnOrderItemService.getById(oldOrderItem.getId());
                BigDecimal num = new BigDecimal(orderItem.getWorkQty().toString()).subtract(new BigDecimal(orderItem.getQty().toString()));
                BigDecimal orderDemandQty = new BigDecimal(oldOrderItem.getDemandQty().toString());
                if (num.compareTo(orderDemandQty) < 0){
@@ -227,8 +227,8 @@
        return wkOrderList.stream().allMatch(item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
    }

    private Boolean checkOrderComplete(AsnOrderItem orderItem) {
        List<AsnOrderItem> asnOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnCode, orderItem.getAsnCode()));
        return asnOrderItems.stream().allMatch(item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
    private Boolean checkOrderComplete(WkOrderItem orderItem) {
        List<WkOrderItem> wkOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnCode, orderItem.getAsnCode()));
        return wkOrderItems.stream().allMatch(item -> new BigDecimal(item.getAnfme().toString()).equals(new BigDecimal(item.getQty().toString())));
    }
}

 rsf-server/src/main/java/com/vincent/rsf/server/api/service/impl/ReportMsgServiceImpl.java

@@ -12,7 +12,7 @@
import com.vincent.rsf.server.api.entity.params.ErpInspectParams;
import com.vincent.rsf.server.api.service.ReportMsgService;
import com.vincent.rsf.server.manager.entity.WkOrder;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.Purchase;
import com.vincent.rsf.server.manager.service.AsnOrderItemService;
import com.vincent.rsf.server.manager.service.AsnOrderService;
@@ -130,24 +130,24 @@
                longSet.add(Long.parseLong(set));
            });

            List<AsnOrderItem> asnOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().in(AsnOrderItem::getPoDetlId, longSet));
            if (asnOrderItems.isEmpty()) {
            List<WkOrderItem> wkOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().in(WkOrderItem::getPoDetlId, longSet));
            if (wkOrderItems.isEmpty()) {
                throw new CoolException("ASN单据不存在！！");
            }
            List<Long> list = asnOrderItems.stream().map(AsnOrderItem::getId).collect(Collectors.toList());
            List<Long> list = wkOrderItems.stream().map(WkOrderItem::getId).collect(Collectors.toList());

            /**************************     修改ASN明细单状态         ******************************/


            if (!asnOrderItemService.update(new LambdaUpdateWrapper<AsnOrderItem>().in(AsnOrderItem::getId, list).set(AsnOrderItem::getNtyStatus, 1))) {
            if (!asnOrderItemService.update(new LambdaUpdateWrapper<WkOrderItem>().in(WkOrderItem::getId, list).set(WkOrderItem::getNtyStatus, 1))) {
                throw new CoolException("ASN明细单据状态修改失败！！");
            }

            /**************************     修改ASN主单数据         ******************************/
            //获取ASN明细订单标识
            List<Long> ids = asnOrderItems.stream().map(AsnOrderItem::getAsnId).collect(Collectors.toList());
            List<Long> ids = wkOrderItems.stream().map(WkOrderItem::getAsnId).collect(Collectors.toList());
            //ASN明细单据分组
            Map<Long, List<AsnOrderItem>> asnIds = asnOrderItems.stream().collect(Collectors.groupingBy(AsnOrderItem::getAsnId));
            Map<Long, List<WkOrderItem>> asnIds = wkOrderItems.stream().collect(Collectors.groupingBy(WkOrderItem::getAsnId));
            ids.forEach(id -> {
                int count = asnOrderService.count(new LambdaQueryWrapper<WkOrder>().in(WkOrder::getId, id));
                if (count == asnIds.get(id).size()) {

 rsf-server/src/main/java/com/vincent/rsf/server/manager/controller/AsnOrderController.java

@@ -8,6 +8,7 @@
import com.vincent.rsf.framework.common.Cools;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.server.manager.entity.WkOrder;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.enums.OrderType;
import com.vincent.rsf.server.manager.enums.OrderWorkType;
import com.vincent.rsf.server.common.utils.ExcelUtil;
@@ -17,7 +18,6 @@
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.controller.params.AsnOrderAndItemsParams;
import com.vincent.rsf.server.manager.controller.params.BatchUpdateParam;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.excel.AsnOrderTemplate;
import com.vincent.rsf.server.manager.service.AsnOrderItemService;
import com.vincent.rsf.server.manager.service.AsnOrderService;
@@ -152,8 +152,8 @@
        }
        List<AsnOrderTemplate> orderTemplates = new ArrayList<>();
        for (WkOrder order : orders) {
            List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, order.getId()));
            for (AsnOrderItem item : orderItems) {
            List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, order.getId()));
            for (WkOrderItem item : orderItems) {
                if (Objects.isNull(item)) {
                    continue;
                }

 rsf-server/src/main/java/com/vincent/rsf/server/manager/controller/AsnOrderItemController.java

@@ -14,9 +14,8 @@
import com.vincent.rsf.server.common.domain.KeyValVo;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.common.utils.FieldsUtils;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.Companys;
import com.vincent.rsf.server.manager.entity.Matnr;
import com.vincent.rsf.server.manager.entity.excel.AsnOrderTemplate;
import com.vincent.rsf.server.manager.enums.CompanysType;
import com.vincent.rsf.server.manager.service.AsnOrderItemService;
@@ -48,11 +47,11 @@
    @PostMapping("/asnOrderItem/page")
    public R page(@RequestBody Map<String, Object> map) {
        BaseParam baseParam = buildParam(map, BaseParam.class);
        PageParam<AsnOrderItem, BaseParam> pageParam = new PageParam<>(baseParam, AsnOrderItem.class);
        PageParam<WkOrderItem, BaseParam> pageParam = new PageParam<>(baseParam, WkOrderItem.class);
        /**拼接扩展字段*/
        PageParam<AsnOrderItem, BaseParam> page = asnOrderItemService.page(pageParam, pageParam.buildWrapper(true));
        List<AsnOrderItem> records = page.getRecords();
        for (AsnOrderItem record : records) {
        PageParam<WkOrderItem, BaseParam> page = asnOrderItemService.page(pageParam, pageParam.buildWrapper(true));
        List<WkOrderItem> records = page.getRecords();
        for (WkOrderItem record : records) {
            if (!Objects.isNull(record.getFieldsIndex())) {
                Map<String, String> fields = FieldsUtils.getFields(record.getFieldsIndex());
                record.setExtendFields(fields);
@@ -100,21 +99,21 @@
    @PreAuthorize("hasAuthority('manager:asnOrderItem:update')")
    @OperationLog("Update ASN单据")
    @PostMapping("/asnOrderItem/update")
    public R update(@RequestBody AsnOrderItem asnOrderItem) {
        asnOrderItem.setUpdateBy(getLoginUserId());
        asnOrderItem.setUpdateTime(new Date());
        if (!Objects.isNull(asnOrderItem.getSplrName()) && StringUtils.isNotBlank(asnOrderItem.getSplrName())) {
    public R update(@RequestBody WkOrderItem wkOrderItem) {
        wkOrderItem.setUpdateBy(getLoginUserId());
        wkOrderItem.setUpdateTime(new Date());
        if (!Objects.isNull(wkOrderItem.getSplrName()) && StringUtils.isNotBlank(wkOrderItem.getSplrName())) {
            Companys companys = companysService.getOne(new LambdaQueryWrapper<Companys>()
                            .eq(Companys::getType, CompanysType.COMPANYS_TYPE_SUPPLIER.val)
                    .eq(Companys::getId, asnOrderItem.getSplrName()));
                    .eq(Companys::getId, wkOrderItem.getSplrName()));
            if (!Objects.isNull(companys)) {
                asnOrderItem.setSplrCode(companys.getCode()).setSplrName(companys.getName());
                wkOrderItem.setSplrCode(companys.getCode()).setSplrName(companys.getName());
            }
        }
        if (!asnOrderItemService.updateById(asnOrderItem)) {
        if (!asnOrderItemService.updateById(wkOrderItem)) {
            return R.error("Update Fail");
        }
        return R.ok("Update Success").add(asnOrderItem);
        return R.ok("Update Success").add(wkOrderItem);
    }

    @PreAuthorize("hasAuthority('manager:asnOrderItem:remove')")
@@ -131,9 +130,9 @@
    @PostMapping("/asnOrderItem/query")
    public R query(@RequestParam(required = false) String condition) {
        List<KeyValVo> vos = new ArrayList<>();
        LambdaQueryWrapper<AsnOrderItem> wrapper = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<WkOrderItem> wrapper = new LambdaQueryWrapper<>();
        if (!Cools.isEmpty(condition)) {
            wrapper.like(AsnOrderItem::getId, condition);
            wrapper.like(WkOrderItem::getId, condition);
        }
        asnOrderItemService.page(new Page<>(1, 30), wrapper).getRecords().forEach(
                item -> vos.add(new KeyValVo(item.getId(), item.getId()))
@@ -145,13 +144,13 @@
    @PostMapping("/asnOrderItem/export")
    @ApiOperation("导出收货通知单明细")
    public void export(@RequestBody Map<String, Object> map, HttpServletResponse response) throws Exception {
        List<AsnOrderItem> orderItems = new ArrayList<>();
        List<WkOrderItem> orderItems = new ArrayList<>();
        if (!Objects.isNull(map.get("ids"))) {
            List<Long> ids = JSONArray.parseArray(JSONObject.toJSONString(map.get("ids")), Long.class);
            if (!ids.isEmpty()) {
                orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                        .in(AsnOrderItem::getId, ids)
                        .eq(AsnOrderItem::getStatus, 1));
                orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                        .in(WkOrderItem::getId, ids)
                        .eq(WkOrderItem::getStatus, 1));
            } else {
                orderItems = asnOrderItemService.list(new LambdaQueryWrapper<>());
            }
@@ -159,7 +158,7 @@
            orderItems = asnOrderItemService.list(new LambdaQueryWrapper<>());
        }

        ExcelUtil.build(ExcelUtil.create(orderItems, AsnOrderItem.class, true), response);
        ExcelUtil.build(ExcelUtil.create(orderItems, WkOrderItem.class, true), response);
    }



 rsf-server/src/main/java/com/vincent/rsf/server/manager/controller/CheckOrderItemController.java

@@ -10,8 +10,7 @@
import com.vincent.rsf.server.common.domain.KeyValVo;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.common.utils.ExcelUtil;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.excel.AsnOrderTemplate;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.excel.CheckOrderTemplate;
import com.vincent.rsf.server.manager.service.CheckOrderItemService;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
@@ -43,8 +42,8 @@
    @PostMapping("/checkItem/page")
    public R page(@RequestBody Map<String, Object> map) {
        BaseParam baseParam = buildParam(map, BaseParam.class);
        PageParam<AsnOrderItem, BaseParam> pageParam = new PageParam<>(baseParam, AsnOrderItem.class);
        QueryWrapper<AsnOrderItem> wrapper = pageParam.buildWrapper(true);
        PageParam<WkOrderItem, BaseParam> pageParam = new PageParam<>(baseParam, WkOrderItem.class);
        QueryWrapper<WkOrderItem> wrapper = pageParam.buildWrapper(true);
        return R.ok().add(checkOrderItemService.page(pageParam, wrapper));
    }

@@ -69,7 +68,7 @@
    @PreAuthorize("hasAuthority('manager:check:save')")
    @OperationLog("Create 字典数据集")
    @PostMapping("/checkItem/save")
    public R save(@RequestBody AsnOrderItem order) {
    public R save(@RequestBody WkOrderItem order) {
        String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_CHECK_RULE_CODE, order);
        if (Objects.isNull(ruleCode)) {
            throw new RuntimeException("盘点单号生成失败！！");
@@ -83,7 +82,7 @@
    @PreAuthorize("hasAuthority('manager:check:update')")
    @OperationLog("Update 字典数据集")
    @PostMapping("/checkItem/update")
    public R update(@RequestBody AsnOrderItem order) {
    public R update(@RequestBody WkOrderItem order) {
        order.setUpdateTime(null);
        order.setUpdateBy(getLoginUserId());
        if (!checkOrderItemService.updateById(order)) {
@@ -106,9 +105,9 @@
    @PostMapping("/checkItem/query")
    public R query(@RequestParam(required = false) String condition) {
        List<KeyValVo> vos = new ArrayList<>();
        LambdaQueryWrapper<AsnOrderItem> wrapper = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<WkOrderItem> wrapper = new LambdaQueryWrapper<>();
        if (!Cools.isEmpty(condition)) {
            wrapper.like(AsnOrderItem::getAsnCode, condition);
            wrapper.like(WkOrderItem::getAsnCode, condition);
        }
        checkOrderItemService.page(new Page<>(1, 20), wrapper).getRecords().forEach(
                item -> vos.add(new KeyValVo(item.getId(), item.getAsnCode()))
@@ -125,13 +124,13 @@
    @PreAuthorize("hasAuthority('manager:check:list')")
    @PostMapping("/checkItem/export")
    public void export(@RequestBody Map<String, Object> map, HttpServletResponse response) throws Exception {
        List<AsnOrderItem> orders = new ArrayList<>();
        List<WkOrderItem> orders = new ArrayList<>();
        if (!Objects.isNull(map.get("ids"))) {
            orders = checkOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().in(AsnOrderItem::getId, map.get("ids")));
            orders = checkOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().in(WkOrderItem::getId, map.get("ids")));
        } else {
            orders = checkOrderItemService.list();
        }
        ExcelUtil.build(ExcelUtil.create(orders, AsnOrderItem.class), response);
        ExcelUtil.build(ExcelUtil.create(orders, WkOrderItem.class), response);
    }

    /**

 rsf-server/src/main/java/com/vincent/rsf/server/manager/controller/OutStockController.java

@@ -14,6 +14,7 @@
import com.vincent.rsf.server.manager.controller.params.OutStockToTaskParams;
import com.vincent.rsf.server.manager.entity.DeliveryItem;
import com.vincent.rsf.server.manager.entity.WkOrder;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.enums.OrderType;
import com.vincent.rsf.server.manager.enums.OrderWorkType;
import com.vincent.rsf.server.common.annotation.OperationLog;
@@ -22,7 +23,6 @@
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.common.utils.ExcelUtil;
import com.vincent.rsf.server.manager.controller.params.AsnOrderAndItemsParams;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.excel.AsnOrderTemplate;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.service.OutStockItemService;
@@ -175,7 +175,7 @@
        if (list.isEmpty()) {
            return R.error("参数不能为空！！");
        }
        List<AsnOrderItem> orderItems = outStockItemService.list(new LambdaQueryWrapper<AsnOrderItem>().in(AsnOrderItem::getId, list));
        List<WkOrderItem> orderItems = outStockItemService.list(new LambdaQueryWrapper<WkOrderItem>().in(WkOrderItem::getId, list));
        if (orderItems.isEmpty()) {
            throw new CoolException("单据明细不存在！！");
        }
@@ -200,8 +200,8 @@
        }
        List<AsnOrderTemplate> orderTemplates = new ArrayList<>();
        for (WkOrder order : orders) {
            List<AsnOrderItem> orderItems = outStockItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, order.getId()));
            for (AsnOrderItem item : orderItems) {
            List<WkOrderItem> orderItems = outStockItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, order.getId()));
            for (WkOrderItem item : orderItems) {
                if (Objects.isNull(item)) {
                    continue;
                }

 rsf-server/src/main/java/com/vincent/rsf/server/manager/controller/OutStockItemController.java

@@ -14,7 +14,7 @@
import com.vincent.rsf.server.common.domain.KeyValVo;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.common.utils.ExcelUtil;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.Companys;
import com.vincent.rsf.server.manager.entity.excel.OutStockTemplate;
import com.vincent.rsf.server.manager.enums.CompanysType;
@@ -47,8 +47,8 @@
    @PostMapping("/outStockItem/page")
    public R page(@RequestBody Map<String, Object> map) {
        BaseParam baseParam = buildParam(map, BaseParam.class);
        PageParam<AsnOrderItem, BaseParam> pageParam = new PageParam<>(baseParam, AsnOrderItem.class);
        QueryWrapper<AsnOrderItem> queryWrapper = pageParam.buildWrapper(true);
        PageParam<WkOrderItem, BaseParam> pageParam = new PageParam<>(baseParam, WkOrderItem.class);
        QueryWrapper<WkOrderItem> queryWrapper = pageParam.buildWrapper(true);
        return R.ok().add(outStockItemService.listByAsnId(pageParam, queryWrapper));
    }

@@ -90,21 +90,21 @@
    @PreAuthorize("hasAuthority('manager:outStockItem:update')")
    @OperationLog("Update 出库单明细")
    @PostMapping("/outStockItem/update")
    public R update(@RequestBody AsnOrderItem asnOrderItem) {
        asnOrderItem.setUpdateBy(getLoginUserId());
        asnOrderItem.setUpdateTime(new Date());
        if (!Objects.isNull(asnOrderItem.getSplrName()) && StringUtils.isNotBlank(asnOrderItem.getSplrName())) {
    public R update(@RequestBody WkOrderItem wkOrderItem) {
        wkOrderItem.setUpdateBy(getLoginUserId());
        wkOrderItem.setUpdateTime(new Date());
        if (!Objects.isNull(wkOrderItem.getSplrName()) && StringUtils.isNotBlank(wkOrderItem.getSplrName())) {
            Companys companys = companysService.getOne(new LambdaQueryWrapper<Companys>()
                            .eq(Companys::getType, CompanysType.COMPANYS_TYPE_SUPPLIER.val)
                    .eq(Companys::getId, asnOrderItem.getSplrName()));
                    .eq(Companys::getId, wkOrderItem.getSplrName()));
            if (!Objects.isNull(companys)) {
                asnOrderItem.setSplrCode(companys.getCode()).setSplrName(companys.getName());
                wkOrderItem.setSplrCode(companys.getCode()).setSplrName(companys.getName());
            }
        }
        if (!outStockItemService.updateById(asnOrderItem)) {
        if (!outStockItemService.updateById(wkOrderItem)) {
            return R.error("Update Fail");
        }
        return R.ok("Update Success").add(asnOrderItem);
        return R.ok("Update Success").add(wkOrderItem);
    }


@@ -122,9 +122,9 @@
    @PostMapping("/outStockItem/query")
    public R query(@RequestParam(required = false) String condition) {
        List<KeyValVo> vos = new ArrayList<>();
        LambdaQueryWrapper<AsnOrderItem> wrapper = new LambdaQueryWrapper<>();
        LambdaQueryWrapper<WkOrderItem> wrapper = new LambdaQueryWrapper<>();
        if (!Cools.isEmpty(condition)) {
            wrapper.like(AsnOrderItem::getId, condition);
            wrapper.like(WkOrderItem::getId, condition);
        }
        outStockItemService.page(new Page<>(1, 30), wrapper).getRecords().forEach(
                item -> vos.add(new KeyValVo(item.getId(), item.getId()))
@@ -137,13 +137,13 @@
    @PostMapping("/outStockItem/export")
    @ApiOperation("导出出库单明细")
    public void export(@RequestBody Map<String, Object> map, HttpServletResponse response) throws Exception {
        List<AsnOrderItem> orderItems = new ArrayList<>();
        List<WkOrderItem> orderItems = new ArrayList<>();
        if (!Objects.isNull(map.get("ids"))) {
            List<Long> ids = JSONArray.parseArray(JSONObject.toJSONString(map.get("ids")), Long.class);
            if (!ids.isEmpty()) {
                orderItems = outStockItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                        .in(AsnOrderItem::getId, ids)
                        .eq(AsnOrderItem::getStatus, 1));
                orderItems = outStockItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                        .in(WkOrderItem::getId, ids)
                        .eq(WkOrderItem::getStatus, 1));
            } else {
                orderItems = outStockItemService.list(new LambdaQueryWrapper<>());
            }
@@ -151,7 +151,7 @@
            orderItems = outStockItemService.list(new LambdaQueryWrapper<>());
        }

        ExcelUtil.build(ExcelUtil.create(orderItems, AsnOrderItem.class, true), response);
        ExcelUtil.build(ExcelUtil.create(orderItems, WkOrderItem.class, true), response);
    }

    /**

 rsf-server/src/main/java/com/vincent/rsf/server/manager/controller/PurchaseController.java

@@ -10,7 +10,7 @@
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.KeyValVo;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.Purchase;
import com.vincent.rsf.server.manager.entity.PurchaseItem;
import com.vincent.rsf.server.manager.enums.POExceStatus;
@@ -116,7 +116,7 @@
    public R remove(@PathVariable Long[] ids) {
        List<Purchase> purchases = purchaseService.listByIds(Arrays.asList(ids));
        Set<String> stringSet = purchases.stream().map(Purchase::getCode).collect(Collectors.toSet());
        List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().in(AsnOrderItem::getPoCode, stringSet));
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().in(WkOrderItem::getPoCode, stringSet));
        if (!orderItems.isEmpty()) {
            return R.error("单据有已生成的收货单明细，不可执行删除操作！！");
        }

 rsf-server/src/main/java/com/vincent/rsf/server/manager/controller/WarehouseAreasItemController.java

@@ -12,8 +12,6 @@
import com.vincent.rsf.server.common.domain.KeyValVo;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.common.utils.FieldsUtils;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.Matnr;
import com.vincent.rsf.server.manager.entity.WarehouseAreasItem;
import com.vincent.rsf.server.manager.service.WarehouseAreasItemService;
import com.vincent.rsf.server.system.controller.BaseController;

 rsf-server/src/main/java/com/vincent/rsf/server/manager/entity/WkOrderItem.java

File was renamed from rsf-server/src/main/java/com/vincent/rsf/server/manager/entity/AsnOrderItem.java
@@ -26,7 +26,7 @@
@Data
@Accessors(chain = true)
@TableName("man_asn_order_item")
public class AsnOrderItem implements Serializable {
public class WkOrderItem implements Serializable {

    private static final long serialVersionUID = 1L;
    /**
@@ -280,9 +280,9 @@
    @TableField(exist = false)
    private Double demandQty = 0.0;
//
    public AsnOrderItem() {}
    public WkOrderItem() {}

    public AsnOrderItem(Long asnId,String asnCode,Long poDetlId, String matnrCode, String poCode,Long matnrId,String matnk,Double anfme,String stockUnit,Double purQty,String purUnit,Double qty,String splrCode,String splrName,String qrcode,String barcode,String packName,Integer status, Integer ntyStatus,Integer deleted,Integer tenantId,Long createBy,Date createTime,Long updateBy,Date updateTime,String memo) {
    public WkOrderItem(Long asnId, String asnCode, Long poDetlId, String matnrCode, String poCode, Long matnrId, String matnk, Double anfme, String stockUnit, Double purQty, String purUnit, Double qty, String splrCode, String splrName, String qrcode, String barcode, String packName, Integer status, Integer ntyStatus, Integer deleted, Integer tenantId, Long createBy, Date createTime, Long updateBy, Date updateTime, String memo) {
        this.asnId = asnId;
        this.asnCode = asnCode;
        this.poDetlId = poDetlId;

 rsf-server/src/main/java/com/vincent/rsf/server/manager/mapper/AsnOrderItemMapper.java

@@ -6,21 +6,20 @@
import com.baomidou.mybatisplus.core.toolkit.Constants;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.springframework.stereotype.Repository;

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

@Mapper
@Repository
public interface AsnOrderItemMapper extends BaseMapper<AsnOrderItem> {
public interface AsnOrderItemMapper extends BaseMapper<WkOrderItem> {

    IPage<Map<String, Object>> resultForMap(PageParam<AsnOrderItem, BaseParam> pages, @Param(Constants.WRAPPER)  QueryWrapper<AsnOrderItem> buildWrapper);
    IPage<Map<String, Object>> resultForMap(PageParam<WkOrderItem, BaseParam> pages, @Param(Constants.WRAPPER)  QueryWrapper<WkOrderItem> buildWrapper);

    AsnOrderItem resultById(@Param(Constants.WRAPPER) LambdaQueryWrapper<AsnOrderItem> buildWrapper);
    WkOrderItem resultById(@Param(Constants.WRAPPER) LambdaQueryWrapper<WkOrderItem> buildWrapper);

}

 rsf-server/src/main/java/com/vincent/rsf/server/manager/mapper/CheckOrderItemMapper.java

@@ -1,12 +1,12 @@
package com.vincent.rsf.server.manager.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface CheckOrderItemMapper extends BaseMapper<AsnOrderItem> {
public interface CheckOrderItemMapper extends BaseMapper<WkOrderItem> {

}

 rsf-server/src/main/java/com/vincent/rsf/server/manager/schedules/AsnOrderLogSchedule.java

@@ -3,7 +3,7 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.manager.entity.WkOrder;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.AsnOrderItemLog;
import com.vincent.rsf.server.manager.entity.AsnOrderLog;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
@@ -94,7 +94,7 @@
     */
    private void moveOrderToLog(List<WkOrder> wkOrders, String type) {
        Set<Long> longSet = wkOrders.stream().map(WkOrder::getId).collect(Collectors.toSet());
        List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().in(AsnOrderItem::getAsnId, longSet));
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().in(WkOrderItem::getAsnId, longSet));
        if (orderItems.isEmpty()) {
            throw new CoolException("收货明细为空！！");
        }
@@ -114,7 +114,7 @@
            }

            List<AsnOrderItemLog> logs = new ArrayList<>();
            List<AsnOrderItem> items = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, order.getId()));
            List<WkOrderItem> items = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, order.getId()));
            items.forEach(item -> {
                AsnOrderItemLog itemLog = new AsnOrderItemLog();
                BeanUtils.copyProperties(item, itemLog);
@@ -129,7 +129,7 @@
            }
        }

        if (!asnOrderItemService.remove(new LambdaQueryWrapper<AsnOrderItem>().in(AsnOrderItem::getAsnId, longSet))) {
        if (!asnOrderItemService.remove(new LambdaQueryWrapper<WkOrderItem>().in(WkOrderItem::getAsnId, longSet))) {
            throw new CoolException("原单据明细删除失败！！");
        }
        if (!this.asnOrderService.removeByIds(longSet)) {

 rsf-server/src/main/java/com/vincent/rsf/server/manager/schedules/ScheduleJobs.java

@@ -81,12 +81,12 @@
        List<WkOrder> orders = asnOrderService.list(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getExceStatus, AsnExceStatus.ASN_EXCE_STATUS_UN_EXCE.val));
        if (!orders.isEmpty()) {
            for (WkOrder order : orders) {
                List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, order.getId()));
                List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, order.getId()));
                if (orderItems.isEmpty()) {
                    return;
                }
                List<WarehouseAreasItem> items = new ArrayList<>();
                for (AsnOrderItem item : orderItems) {
                for (WkOrderItem item : orderItems) {
                    WarehouseAreas one = warehouseAreasService.getOne(new LambdaQueryWrapper<WarehouseAreas>()
                            .eq(WarehouseAreas::getType, WarehouseAreasType.WAREHOUSE_AREAS_TYPE_RECEIPT.type), false);
                    Long areaId = Objects.isNull(one) ? null : one.getId();
@@ -107,7 +107,7 @@
                    //更新收货区库存
                    extracted(one, item, order, matnr);

                    if (!asnOrderItemService.update(new LambdaUpdateWrapper<AsnOrderItem>().set(AsnOrderItem::getQty, item.getAnfme()).eq(AsnOrderItem::getId, item.getId()))) {
                    if (!asnOrderItemService.update(new LambdaUpdateWrapper<WkOrderItem>().set(WkOrderItem::getQty, item.getAnfme()).eq(WkOrderItem::getId, item.getId()))) {
                        throw new CoolException("收货单明细完成数量修改失败！！");
                    }
                }
@@ -132,7 +132,7 @@
     * @description: 收货区库存更新
     * @version 1.0
     */
    private void extracted(WarehouseAreas areasItem, AsnOrderItem orderItem, WkOrder wkOrder, Matnr matnr) {
    private void extracted(WarehouseAreas areasItem, WkOrderItem orderItem, WkOrder wkOrder, Matnr matnr) {
        Companys companys = new Companys();
        if (StringUtils.isNoneBlank(orderItem.getSplrCode())) {
            companys = companysService.getOne(new LambdaQueryWrapper<Companys>().eq(Companys::getCode, orderItem.getSplrCode()));
@@ -231,9 +231,9 @@
            if (!asnOrderService.save(order)) {
                throw new CoolException("ASN单据保存失败！！");
            }
            List<AsnOrderItem> orderItems = new ArrayList<>();
            List<WkOrderItem> orderItems = new ArrayList<>();
            items.forEach(item -> {
                AsnOrderItem orderItem = new AsnOrderItem();
                WkOrderItem orderItem = new WkOrderItem();
                Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>().eq(Matnr::getCode, item.getMatnrCode()));
                if (Objects.isNull(matnr)) {
                    throw new CoolException("数据错误：当前物料不存在!!");
@@ -284,13 +284,13 @@
    @Scheduled(cron = "0 0/05 * * * ?  ")
    @Transactional(rollbackFor = Exception.class)
    public void generateMatnrLabel() {
        List<AsnOrderItem> list = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                .isNull(AsnOrderItem::getTrackCode)
                .select(AsnOrderItem::getId));
        List<WkOrderItem> list = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .isNull(WkOrderItem::getTrackCode)
                .select(WkOrderItem::getId));
        if (Objects.isNull(list) || list.isEmpty()) {
            return;
        }
        List<AsnOrderItem> items = new ArrayList<>();
        List<WkOrderItem> items = new ArrayList<>();
        list.forEach(item -> {
            String trackCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_LABEL_CODE, item);
            if (StringUtils.isBlank(trackCode)) {

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/AsnOrderItemService.java

@@ -6,14 +6,14 @@
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import org.springframework.web.multipart.MultipartFile;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public interface AsnOrderItemService extends IService<AsnOrderItem> {
public interface AsnOrderItemService extends IService<WkOrderItem> {


    R excelImport(MultipartFile file, HashMap<String, Object> hashMap, Long loginUserId) throws Exception;
@@ -22,6 +22,6 @@

    R generateBarcode(List<Long> orders);

    IPage<Map<String, Object>> listByAsnId(PageParam<AsnOrderItem, BaseParam> pageParam, QueryWrapper<AsnOrderItem> buildWrapper);
    IPage<Map<String, Object>> listByAsnId(PageParam<WkOrderItem, BaseParam> pageParam, QueryWrapper<WkOrderItem> buildWrapper);

}

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/CheckOrderItemService.java

@@ -1,7 +1,7 @@
package com.vincent.rsf.server.manager.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;

public interface CheckOrderItemService extends IService<AsnOrderItem> {
public interface CheckOrderItemService extends IService<WkOrderItem> {
}

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/OutStockItemService.java

@@ -6,20 +6,18 @@
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.LocItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import org.springframework.web.multipart.MultipartFile;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

public interface OutStockItemService extends IService<AsnOrderItem> {
public interface OutStockItemService extends IService<WkOrderItem> {

    boolean fieldsSave(Map<String, Object> params);

    R excelImport(MultipartFile file, HashMap<String, Object> hashMap, Long loginUserId) throws Exception;

    IPage<Map<String, Object>> listByAsnId(PageParam<AsnOrderItem, BaseParam> pageParam, QueryWrapper<AsnOrderItem> buildWrapper);
    IPage<Map<String, Object>> listByAsnId(PageParam<WkOrderItem, BaseParam> pageParam, QueryWrapper<WkOrderItem> buildWrapper);

}

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/OutStockService.java

@@ -7,7 +7,7 @@
import com.vincent.rsf.server.manager.controller.params.OrderOutTaskParam;
import com.vincent.rsf.server.manager.controller.params.OutStockToTaskParams;
import com.vincent.rsf.server.manager.entity.WkOrder;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.DeliveryItem;

import java.util.List;
@@ -30,6 +30,6 @@

    R getSiteNos();

    R cancelOutOrderByItems(List<AsnOrderItem> orderItems);
    R cancelOutOrderByItems(List<WkOrderItem> orderItems);

}

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/QlyInspectService.java

@@ -4,7 +4,7 @@
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.server.manager.controller.params.IsptOrderParam;
import com.vincent.rsf.server.manager.controller.params.QlyInspectAndItem;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.QlyInspect;
import com.vincent.rsf.server.manager.entity.WarehouseAreasItem;

@@ -13,7 +13,7 @@

public interface QlyInspectService extends IService<QlyInspect> {

    List<AsnOrderItem> listByAsn(Map<String, Object> map);
    List<WkOrderItem> listByAsn(Map<String, Object> map);

    R allSave(QlyInspectAndItem params);


 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderItemServiceImpl.java

@@ -11,6 +11,7 @@
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.manager.entity.WkOrder;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.enums.OrderType;
import com.vincent.rsf.server.manager.enums.OrderWorkType;
import com.vincent.rsf.server.common.domain.BaseParam;
@@ -23,7 +24,6 @@
import com.vincent.rsf.server.manager.enums.CompanysType;
import com.vincent.rsf.server.manager.enums.QlyIsptResult;
import com.vincent.rsf.server.manager.mapper.AsnOrderItemMapper;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.service.AsnOrderItemService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vincent.rsf.server.manager.service.AsnOrderService;
@@ -45,7 +45,7 @@
import java.util.stream.Collectors;

@Service("asnOrderItemService")
public class AsnOrderItemServiceImpl extends ServiceImpl<AsnOrderItemMapper, AsnOrderItem> implements AsnOrderItemService {
public class AsnOrderItemServiceImpl extends ServiceImpl<AsnOrderItemMapper, WkOrderItem> implements AsnOrderItemService {

    @Autowired
    private AsnOrderService asnOrderMapper;
@@ -72,7 +72,7 @@
        if (Objects.isNull(orders) || orders.isEmpty()) {
            throw new CoolException("参数不能为空！！");
        }
        List<AsnOrderItem> items = this.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getId, orders));
        List<WkOrderItem> items = this.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getId, orders));
        if (items.isEmpty()) {
            throw new CoolException("单据明细不存在！！");
        }
@@ -137,9 +137,9 @@
            if (!asnOrderMapper.save(order)) {
                throw new CoolException("单据保存失败！！");
            }
            List<AsnOrderItem> items = new ArrayList<>();
            List<WkOrderItem> items = new ArrayList<>();
            for (AsnOrderTemplate orderTemplate : listMap.get(key)) {
                AsnOrderItem orderItem = new AsnOrderItem();
                WkOrderItem orderItem = new WkOrderItem();
                if (StringUtils.isBlank(orderTemplate.getMatnrCode())) {
                    throw new CoolException(orderTemplate.getCode() + "：物料编码不能为空！！");
                }
@@ -202,7 +202,7 @@
            }
            if (!items.isEmpty()) {
//                double qty = items.stream().mapToDouble(AsnOrderItem::getQty).sum();
                double anfme = items.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
                double anfme = items.stream().mapToDouble(WkOrderItem::getAnfme).sum();
                if (!asnOrderMapper.update(new LambdaUpdateWrapper<WkOrder>()
//                        .set(AsnOrder::getQty, qty)
                        .set(WkOrder::getAnfme, anfme)
@@ -226,26 +226,26 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean fieldsSave(Map<String, Object> params, Long loginUserId) {
        AsnOrderItem asnOrderItem = JSONObject.parseObject(JSONObject.toJSONString(params), AsnOrderItem.class);
        if (StringUtils.isNoneBlank(asnOrderItem.getSplrCode())) {
        WkOrderItem wkOrderItem = JSONObject.parseObject(JSONObject.toJSONString(params), WkOrderItem.class);
        if (StringUtils.isNoneBlank(wkOrderItem.getSplrCode())) {
            Companys companys = companysService.getOne(new LambdaQueryWrapper<Companys>()
                    .eq(Companys::getId, asnOrderItem.getSplrCode())
                    .eq(Companys::getId, wkOrderItem.getSplrCode())
                    .eq(Companys::getType, CompanysType.COMPANYS_TYPE_SUPPLIER.val));
            if (!Objects.isNull(companys)) {
                asnOrderItem.setSplrCode(companys.getCode()).setSplrName(companys.getName());
                wkOrderItem.setSplrCode(companys.getCode()).setSplrName(companys.getName());
            }
        }
        if (Objects.isNull(asnOrderItem.getAnfme()) || Double.compare(asnOrderItem.getAnfme(), 0.0) <= 0) {
        if (Objects.isNull(wkOrderItem.getAnfme()) || Double.compare(wkOrderItem.getAnfme(), 0.0) <= 0) {
            throw new CoolException("计划数不能为空！！");
        }
        //保存扩展字段
        try {
            StringBuffer sb = new StringBuffer();
            if (Objects.isNull(asnOrderItem.getFieldsIndex()) || StringUtils.isBlank(asnOrderItem.getFieldsIndex())) {
                sb.append(asnOrderItem.getMatnrId() + asnOrderItem.getSplrBatch() );
            if (Objects.isNull(wkOrderItem.getFieldsIndex()) || StringUtils.isBlank(wkOrderItem.getFieldsIndex())) {
                sb.append(wkOrderItem.getMatnrId() + wkOrderItem.getSplrBatch() );
                //获取16位uuid
                String uuid16 = Cools.md5Chinese(sb.toString());
                asnOrderItem.setFieldsIndex(uuid16);
                wkOrderItem.setFieldsIndex(uuid16);
                params.put("index", uuid16);
            }
            //保存或更新动态字段值
@@ -253,15 +253,15 @@
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        asnOrderItem.setUpdateBy(loginUserId).setCreateBy(loginUserId);
        if (!this.saveOrUpdate(asnOrderItem)) {
        wkOrderItem.setUpdateBy(loginUserId).setCreateBy(loginUserId);
        if (!this.saveOrUpdate(wkOrderItem)) {
            throw new CoolException("收货通知单明细保存失败！！");
        }
        return true;
    }

    @Override
    public IPage<Map<String, Object>> listByAsnId(PageParam<AsnOrderItem, BaseParam> pageParam, QueryWrapper<AsnOrderItem> buildWrapper) {
    public IPage<Map<String, Object>> listByAsnId(PageParam<WkOrderItem, BaseParam> pageParam, QueryWrapper<WkOrderItem> buildWrapper) {
        IPage<Map<String, Object>> hsahMap = this.baseMapper.resultForMap(pageParam, buildWrapper);
        if (hsahMap.getRecords().isEmpty()) {
            return hsahMap.setRecords(new ArrayList<>());

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderLogServiceImpl.java

@@ -4,7 +4,7 @@
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.manager.entity.WkOrder;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.AsnOrderItemLog;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.mapper.AsnOrderLogMapper;
@@ -63,10 +63,10 @@
        List<AsnOrderItemLog> itemLogs = asnOrderItemLogService
                .list(new LambdaQueryWrapper<AsnOrderItemLog>()
                .eq(AsnOrderItemLog::getLogId, id));
        List<AsnOrderItem> orderItems = new ArrayList<>();
        List<WkOrderItem> orderItems = new ArrayList<>();
        if (!Objects.isNull(itemLogs) || !itemLogs.isEmpty()) {
            for (AsnOrderItemLog itemLog : itemLogs) {
                AsnOrderItem item = new AsnOrderItem();
                WkOrderItem item = new WkOrderItem();
                BeanUtils.copyProperties(itemLog, item);
                item.setId(itemLog.getAsnItemId())
                        .setAsnId(order.getId())

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/AsnOrderServiceImpl.java

@@ -85,13 +85,13 @@
        if (Objects.isNull(params)) {
            throw new CoolException("查询条件不能为空！！");
        }
        List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                .like(!Objects.isNull(params.get("maktx")), AsnOrderItem::getMaktx, params.get("maktx"))
                .eq(!Objects.isNull(params.get("matnrCode")), AsnOrderItem::getMatnrCode, params.get("matnrCode")));
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .like(!Objects.isNull(params.get("maktx")), WkOrderItem::getMaktx, params.get("maktx"))
                .eq(!Objects.isNull(params.get("matnrCode")), WkOrderItem::getMatnrCode, params.get("matnrCode")));
        if (orderItems.isEmpty()) {
            return new ArrayList<>();
        }
        List<Long> longList = orderItems.stream().map(AsnOrderItem::getAsnId).collect(Collectors.toList());
        List<Long> longList = orderItems.stream().map(WkOrderItem::getAsnId).collect(Collectors.toList());

        return this.listByIds(longList);
    }
@@ -175,9 +175,9 @@
                throw new CoolException("明细保存失败！！");
            }
        });
        List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnId, params.getOrders().getId()));
        double sum = orderItems.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getAsnId, params.getOrders().getId()));
        double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
        orders.setAnfme(sum);
        if (!this.updateById(orders)) {
            throw new CoolException("计划收货数量修改失败！！");
@@ -276,9 +276,9 @@
        if (!this.save(order)) {
            throw new CoolException("ASN单据保存失败！！");
        }
        List<AsnOrderItem> orderItems = new ArrayList<>();
        List<WkOrderItem> orderItems = new ArrayList<>();
        for (PurchaseItem item : itemList) {
            AsnOrderItem orderItem = new AsnOrderItem();
            WkOrderItem orderItem = new WkOrderItem();
            Matnr matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>().eq(Matnr::getCode, item.getMatnrCode()));
            if (Objects.isNull(matnr)) {
                throw new CoolException("数据错误：当前物料不存在!!");
@@ -323,7 +323,7 @@
            }
        }

        double sum = orderItems.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
        double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();

        if (!asnOrderItemService.saveBatch(orderItems)) {
            throw new CoolException(("Asn单据明细保存失败！！"));
@@ -354,8 +354,8 @@
    @Transactional(rollbackFor = Exception.class)
    public R removeOrders(List<Long> ids) {
        for (Long id : ids) {
            List<AsnOrderItem> list = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                    .eq(AsnOrderItem::getAsnId, id));
            List<WkOrderItem> list = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                    .eq(WkOrderItem::getAsnId, id));
            if (list.isEmpty()) {
                continue;
            }
@@ -371,7 +371,7 @@
                }
            });

            double sum = list.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
            double sum = list.stream().mapToDouble(WkOrderItem::getAnfme).sum();

            Purchase purchase = purchaseService.getOne(new LambdaQueryWrapper<Purchase>()
                    .eq(Purchase::getCode, list.stream().findFirst().get().getPoCode()));
@@ -393,8 +393,8 @@
        }


        if (!asnOrderItemService.remove(new LambdaQueryWrapper<AsnOrderItem>()
                .in(AsnOrderItem::getAsnId, ids))) {
        if (!asnOrderItemService.remove(new LambdaQueryWrapper<WkOrderItem>()
                .in(WkOrderItem::getAsnId, ids))) {
//            throw new CoolException("Details Delete Fail");
        }

@@ -418,7 +418,7 @@
        if (!this.updateById(asrder)) {
            throw new CoolException("单据关闭失败！！");
        }
        List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, asrder.getId()));
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, asrder.getId()));
        if (orderItems.isEmpty()) {
            throw new CoolException("收货明细为空！！");
        }
@@ -440,7 +440,7 @@
            throw new CoolException("主单历史档添加失败！！");
        }
        List<AsnOrderItemLog> logs = new ArrayList<>();
        List<AsnOrderItem> items = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, order.getId()));
        List<WkOrderItem> items = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, order.getId()));
        items.forEach(item -> {
            AsnOrderItemLog itemLog = new AsnOrderItemLog();
            BeanUtils.copyProperties(item, itemLog);
@@ -453,7 +453,7 @@
        if (!asnOrderItemLogService.saveBatch(logs)) {
            throw new CoolException("通知单明细历史档保存失败！！");
        }
        if (!asnOrderItemService.remove(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, order.getId()))) {
        if (!asnOrderItemService.remove(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, order.getId()))) {
            throw new CoolException("原单据明细删除失败！！");
        }
        if (!this.removeById(asrder.getId())) {

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/CheckOrderItemServiceImpl.java

@@ -1,12 +1,12 @@
package com.vincent.rsf.server.manager.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.mapper.CheckOrderItemMapper;
import com.vincent.rsf.server.manager.service.CheckOrderItemService;
import org.springframework.stereotype.Service;

@Service("checkOrderItemService")
public class CheckOrderItemServiceImpl extends ServiceImpl<CheckOrderItemMapper, AsnOrderItem> implements CheckOrderItemService {
public class CheckOrderItemServiceImpl extends ServiceImpl<CheckOrderItemMapper, WkOrderItem> implements CheckOrderItemService {

}

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/CheckOrderServiceImpl.java

@@ -10,7 +10,7 @@
import com.vincent.rsf.server.common.utils.ExcelUtil;
import com.vincent.rsf.server.manager.controller.params.AsnOrderAndItemsParams;
import com.vincent.rsf.server.manager.entity.WkOrder;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.Matnr;
import com.vincent.rsf.server.manager.entity.excel.CheckOrderTemplate;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
@@ -79,9 +79,9 @@
            if (!this.save(order)) {
                throw new CoolException("单据保存失败！！");
            }
            List<AsnOrderItem> items = new ArrayList<>();
            List<WkOrderItem> items = new ArrayList<>();
            for (CheckOrderTemplate orderTemplate : listMap.get(key)) {
                AsnOrderItem orderItem = new AsnOrderItem();
                WkOrderItem orderItem = new WkOrderItem();
                Matnr matnr = null;
                if (StringUtils.isNotBlank(orderTemplate.getMatnrCode())) {
                    matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>()
@@ -104,7 +104,7 @@
                }
            }
            if (!items.isEmpty()) {
                double purQty = items.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
                double purQty = items.stream().mapToDouble(WkOrderItem::getAnfme).sum();
                if (!this.update(new LambdaUpdateWrapper<WkOrder>()
                        .set(WkOrder::getExceStatus, AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val)
                        .set(WkOrder::getAnfme, purQty).eq(WkOrder::getId, order.getId()))) {
@@ -178,9 +178,9 @@
                throw new CoolException("明细保存失败！！");
            }
        });
        List<AsnOrderItem> orderItems = checkOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnId, params.getOrders().getId()));
        Double sum = orderItems.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
        List<WkOrderItem> orderItems = checkOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getAsnId, params.getOrders().getId()));
        Double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
        orders.setAnfme(sum);
        if (!this.updateById(orders)) {
            throw new CoolException("计划收货数量修改失败！！");

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/OutStockItemServiceImpl.java

@@ -11,6 +11,7 @@
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.manager.entity.WkOrder;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.entity.excel.OutStockTemplate;
import com.vincent.rsf.server.manager.enums.AsnExceStatus;
import com.vincent.rsf.server.manager.enums.OrderType;
@@ -20,7 +21,6 @@
import com.vincent.rsf.server.common.utils.CommonUtil;
import com.vincent.rsf.server.common.utils.ExcelUtil;
import com.vincent.rsf.server.common.utils.FieldsUtils;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.Matnr;
import com.vincent.rsf.server.manager.mapper.AsnOrderItemMapper;
import com.vincent.rsf.server.manager.service.MatnrService;
@@ -45,7 +45,7 @@
 * @create 2025/4/22 11:35
 */
@Service("outStockItemServiceImpl")
public class OutStockItemServiceImpl extends ServiceImpl<AsnOrderItemMapper, AsnOrderItem> implements OutStockItemService {
public class OutStockItemServiceImpl extends ServiceImpl<AsnOrderItemMapper, WkOrderItem> implements OutStockItemService {

    @Autowired
    private OutStockService outStockService;
@@ -64,13 +64,13 @@
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean fieldsSave(Map<String, Object> params) {
        AsnOrderItem asnOrderItem = JSONObject.parseObject(JSONObject.toJSONString(params), AsnOrderItem.class);
        if (StringUtils.isBlank(asnOrderItem.getTrackCode())) {
            String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_LABEL_CODE, asnOrderItem);
            asnOrderItem.setTrackCode(ruleCode).setBarcode(ruleCode);
        WkOrderItem wkOrderItem = JSONObject.parseObject(JSONObject.toJSONString(params), WkOrderItem.class);
        if (StringUtils.isBlank(wkOrderItem.getTrackCode())) {
            String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_LABEL_CODE, wkOrderItem);
            wkOrderItem.setTrackCode(ruleCode).setBarcode(ruleCode);
            ;
        }
        if (Objects.isNull(asnOrderItem.getAnfme()) || Double.compare(asnOrderItem.getAnfme(), 0.0) <= 0) {
        if (Objects.isNull(wkOrderItem.getAnfme()) || Double.compare(wkOrderItem.getAnfme(), 0.0) <= 0) {
            throw new CoolException("计划收货数不能为空！！");
        }
        //保存扩展字段
@@ -78,12 +78,12 @@
            String uuid16 = CommonUtil.randomUUID16();
            Boolean fields = FieldsUtils.saveFields(params, uuid16);
            if (fields) {
                asnOrderItem.setFieldsIndex(uuid16);
                wkOrderItem.setFieldsIndex(uuid16);
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        if (!this.saveOrUpdate(asnOrderItem)) {
        if (!this.saveOrUpdate(wkOrderItem)) {
            throw new CoolException("收货通知单明细保存失败！！");
        }
        return true;
@@ -122,9 +122,9 @@
            if (!outStockService.save(order)) {
                throw new CoolException("单据保存失败！！");
            }
            List<AsnOrderItem> items = new ArrayList<>();
            List<WkOrderItem> items = new ArrayList<>();
            for (OutStockTemplate orderTemplate : listMap.get(key)) {
                AsnOrderItem orderItem = new AsnOrderItem();
                WkOrderItem orderItem = new WkOrderItem();
                Matnr matnr = null;
                if (StringUtils.isNotBlank(orderTemplate.getMatnrCode())) {
                    matnr = matnrService.getOne(new LambdaQueryWrapper<Matnr>()
@@ -148,7 +148,7 @@
                }
            }
            if (!items.isEmpty()) {
                double purQty = items.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
                double purQty = items.stream().mapToDouble(WkOrderItem::getAnfme).sum();
                if (!outStockService.update(new LambdaUpdateWrapper<WkOrder>()
                                .set(WkOrder::getExceStatus, AsnExceStatus.OUT_STOCK_STATUS_TASK_INIT.val)
                        .set(WkOrder::getAnfme, purQty).eq(WkOrder::getId, order.getId()))) {
@@ -168,7 +168,7 @@
     * @time 2025/4/22 12:39
     */
    @Override
    public IPage<Map<String, Object>> listByAsnId(PageParam<AsnOrderItem, BaseParam> pageParam, QueryWrapper<AsnOrderItem> buildWrapper) {
    public IPage<Map<String, Object>> listByAsnId(PageParam<WkOrderItem, BaseParam> pageParam, QueryWrapper<WkOrderItem> buildWrapper) {
        IPage<Map<String, Object>> hsahMap = this.baseMapper.resultForMap(pageParam, buildWrapper);
        if (hsahMap.getRecords().isEmpty()) {
            return hsahMap.setRecords(new ArrayList<>());

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/OutStockServiceImpl.java

@@ -98,9 +98,9 @@
                throw new CoolException("明细保存失败！！");
            }
        });
        List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnId, params.getOrders().getId()));
        Double sum = orderItems.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getAsnId, params.getOrders().getId()));
        Double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
        orders.setAnfme(sum);
        if (!this.updateById(orders)) {
            throw new CoolException("计划收货数量修改失败！！");
@@ -129,9 +129,9 @@
            throw new CoolException("当前单据状态为" + AsnExceStatus.getExceStatus(order.getExceStatus()) + "， 不可执行取消操作！！");
        }

        List<AsnOrderItem> orderItems = outStockItemService.list(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, id));
        List<WkOrderItem> orderItems = outStockItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, id));
        if (!orderItems.isEmpty()) {
            for (AsnOrderItem orderItem : orderItems) {
            for (WkOrderItem orderItem : orderItems) {
                if (!Objects.isNull(orderItem.getPoDetlId())) {
                    DeliveryItem deliveryItem = deliveryItemService.getById(orderItem.getPoDetlId());
                    Double workQty = Math.round((deliveryItem.getWorkQty() - orderItem.getAnfme()) * 10000) / 10000.0;
@@ -155,7 +155,7 @@
        if (!this.remove(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getId, id))) {
            throw new CoolException("主单删除失败！！");
        }
        if (!outStockItemService.remove(new LambdaQueryWrapper<AsnOrderItem>().eq(AsnOrderItem::getAsnId, id))) {
        if (!outStockItemService.remove(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getAsnId, id))) {
            throw new CoolException("单据明细删除失败！！");
        }
        return R.ok("操作成功");
@@ -201,10 +201,10 @@
            if (!this.save(order)) {
                throw new CoolException("主单保存失败！！");
            }
            List<AsnOrderItem> orderItems = new ArrayList<>();
            List<WkOrderItem> orderItems = new ArrayList<>();
            listMap.get(key).forEach(item -> {
                DeliveryItem deliveryItem = deliveryItemService.getById(item.getId());
                AsnOrderItem orderItem = new AsnOrderItem();
                WkOrderItem orderItem = new WkOrderItem();
                if (item.getAnfme().compareTo(0.0) <= 0) {
                    throw new CoolException("出库数量不能小于或等于零！！");
                }
@@ -241,7 +241,7 @@
                }
            });

            Double sum = orderItems.stream().mapToDouble(AsnOrderItem::getAnfme).sum();
            Double sum = orderItems.stream().mapToDouble(WkOrderItem::getAnfme).sum();
            //修改计划数量
            order.setAnfme(sum).setWorkQty(0.0);
            if (!this.saveOrUpdate(order)) {
@@ -304,9 +304,9 @@
        }

        List<Long> list = orders.stream().map(WkOrder::getId).collect(Collectors.toList());
        List<AsnOrderItem> orderItems = asnOrderItemService
                .list(new LambdaQueryWrapper<AsnOrderItem>()
                        .in(AsnOrderItem::getAsnId, list).apply("anfme > work_qty"));
        List<WkOrderItem> orderItems = asnOrderItemService
                .list(new LambdaQueryWrapper<WkOrderItem>()
                        .in(WkOrderItem::getAsnId, list).apply("anfme > work_qty"));
        if (orderItems.isEmpty()) {
            throw new CoolException("单据不存在！！");
        }
@@ -330,7 +330,7 @@
         *订单信息存储至逻辑关联表
         */
        for (WaveItem item : waveItems) {
            List<AsnOrderItem> items = orderItems.stream()
            List<WkOrderItem> items = orderItems.stream()
                    .filter(orderItem -> item.getMatnrId()
                            .equals(orderItem.getMatnrId()))
                    .collect(Collectors.toList());
@@ -485,11 +485,11 @@
                List<LocItem> locItems = new ArrayList<>();
                LocItem locItem = locItemService.getById(param.getId());

                AsnOrderItem orderItem = outStockItemService.getOne(new LambdaQueryWrapper<AsnOrderItem>()
                        .eq(AsnOrderItem::getAsnId, outId)
                        .eq(StringUtils.isNotBlank(locItem.getBatch()), AsnOrderItem::getSplrBatch, locItem.getBatch())
                        .eq(StringUtils.isNotBlank(locItem.getFieldsIndex()), AsnOrderItem::getFieldsIndex, locItem.getFieldsIndex())
                        .eq(AsnOrderItem::getMatnrId, locItem.getMatnrId()));
                WkOrderItem orderItem = outStockItemService.getOne(new LambdaQueryWrapper<WkOrderItem>()
                        .eq(WkOrderItem::getAsnId, outId)
                        .eq(StringUtils.isNotBlank(locItem.getBatch()), WkOrderItem::getSplrBatch, locItem.getBatch())
                        .eq(StringUtils.isNotBlank(locItem.getFieldsIndex()), WkOrderItem::getFieldsIndex, locItem.getFieldsIndex())
                        .eq(WkOrderItem::getMatnrId, locItem.getMatnrId()));

                if (Objects.isNull(orderItem)) {
                    throw new CoolException("单据明细不存在！！");
@@ -561,16 +561,16 @@

    @Override
    @Transactional(rollbackFor = Exception.class)
    public R cancelOutOrderByItems(List<AsnOrderItem> orderItems) {
        Map<Long, List<AsnOrderItem>> listMap = orderItems.stream().collect(Collectors.groupingBy(AsnOrderItem::getAsnId));
    public R cancelOutOrderByItems(List<WkOrderItem> orderItems) {
        Map<Long, List<WkOrderItem>> listMap = orderItems.stream().collect(Collectors.groupingBy(WkOrderItem::getAsnId));
        for (Long key : listMap.keySet()) {
            WkOrder order = this.getById(key);
            if (Objects.isNull(order)) {
                throw new CoolException("单据不存在！！");
            }
            List<AsnOrderItem> items = listMap.get(key);
            List<WkOrderItem> items = listMap.get(key);
            if (!items.isEmpty()) {
                for (AsnOrderItem orderItem : items) {
                for (WkOrderItem orderItem : items) {
                    DeliveryItem deliveryItem = deliveryItemService.getById(orderItem.getPoDetlId());
                    Double workQty = Math.round((deliveryItem.getWorkQty() - orderItem.getAnfme()) * 10000) / 10000.0;
                    deliveryItem.setWorkQty(workQty.compareTo(0.0) >= 0 ? workQty : 0);
@@ -592,8 +592,8 @@
            if (!this.remove(new LambdaQueryWrapper<WkOrder>().eq(WkOrder::getId, key))) {
                throw new CoolException("主单删除失败！！");
            }
            if (!outStockItemService.remove(new LambdaQueryWrapper<AsnOrderItem>()
                    .eq(AsnOrderItem::getAsnId, key))) {
            if (!outStockItemService.remove(new LambdaQueryWrapper<WkOrderItem>()
                    .eq(WkOrderItem::getAsnId, key))) {
                throw new CoolException("单据明细删除失败！！");
            }
        }
@@ -602,24 +602,24 @@


    private List<OrderOutItemDto> getOutOrderList(Long orderId, WaveRule waveRule) {
        List<AsnOrderItem> asnOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnId, orderId));
        List<WkOrderItem> wkOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getAsnId, orderId));
        List<OrderOutItemDto> list = new ArrayList<>();
        Set<ExistDto> existDtos = new HashSet<>();
        for (AsnOrderItem asnOrderItem : asnOrderItems) {
            BigDecimal issued = new BigDecimal(asnOrderItem.getAnfme().toString())
                    .subtract(new BigDecimal(asnOrderItem.getWorkQty().toString())
        for (WkOrderItem wkOrderItem : wkOrderItems) {
            BigDecimal issued = new BigDecimal(wkOrderItem.getAnfme().toString())
                    .subtract(new BigDecimal(wkOrderItem.getWorkQty().toString())
                    );
            if (issued.doubleValue() <= 0) {
                continue;
            }
            List<LocItem> locItems = new ArrayList<>();
            if (WaveRuleType.Efficiency_First.type.equals(waveRule.getType())) {
                locItems = LocManageUtil.getEfficiencyFirstItemList(asnOrderItem.getMatnrCode(), asnOrderItem.getSplrBatch(), asnOrderItem.getAnfme());
                locItems = LocManageUtil.getEfficiencyFirstItemList(wkOrderItem.getMatnrCode(), wkOrderItem.getSplrBatch(), wkOrderItem.getAnfme());
            } else if (WaveRuleType.First_In_First_Out.type.equals(waveRule.getType())) {
                locItems = LocManageUtil.getFirstInFirstOutItemList(asnOrderItem.getMatnrCode(), asnOrderItem.getSplrBatch(), asnOrderItem.getAnfme());
                locItems = LocManageUtil.getFirstInFirstOutItemList(wkOrderItem.getMatnrCode(), wkOrderItem.getSplrBatch(), wkOrderItem.getAnfme());
            } else {
                locItems = LocManageUtil.getFirstInFirstOutItemList(asnOrderItem.getMatnrCode(), asnOrderItem.getSplrBatch(), asnOrderItem.getAnfme());
                locItems = LocManageUtil.getFirstInFirstOutItemList(wkOrderItem.getMatnrCode(), wkOrderItem.getSplrBatch(), wkOrderItem.getAnfme());
            }
            for (LocItem locItem : locItems) {
                Loc loc = locService.getById(locItem.getLocId());
@@ -660,13 +660,13 @@
            if (issued.doubleValue() > 0) {
                LocItem locItem = new LocItem()
                        .setId(new Random().nextLong())
                        .setMatnrCode(asnOrderItem.getMatnrCode())
                        .setMaktx(asnOrderItem.getMaktx())
                        .setMatnrCode(wkOrderItem.getMatnrCode())
                        .setMaktx(wkOrderItem.getMaktx())
                        .setAnfme(0.00)
                        .setWorkQty(issued.doubleValue())
                        .setOutQty(issued.doubleValue())
                        .setUnit(asnOrderItem.getStockUnit())
                        .setBatch(asnOrderItem.getSplrBatch());
                        .setUnit(wkOrderItem.getStockUnit())
                        .setBatch(wkOrderItem.getSplrBatch());
                OrderOutItemDto orderOutItemDto = new OrderOutItemDto();
                orderOutItemDto.setLocItem(locItem);
                list.add(orderOutItemDto);
@@ -685,7 +685,7 @@
     * @description 合并生成波次
     * @time 2025/4/25 10:07
     */
    private List<WaveItem> mergeWave(List<AsnOrderItem> orderItems, Wave wave) {
    private List<WaveItem> mergeWave(List<WkOrderItem> orderItems, Wave wave) {
        List<WaveItem> items = new ArrayList<>();
        orderItems.forEach(order -> {
            Double anfme = Math.round((order.getAnfme() - order.getWorkQty()) * 10000) / 10000.0;

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/QlyInspectServiceImpl.java

@@ -44,7 +44,7 @@
    private WarehouseAreasItemService warehouseAreasItemService;

    @Override
    public List<AsnOrderItem> listByAsn(Map<String, Object> map) {
    public List<WkOrderItem> listByAsn(Map<String, Object> map) {
        if (Objects.isNull(map.get("asnCode"))) {
            throw new CoolException("收货单据明细编码不能为空！！");
        }
@@ -54,13 +54,13 @@
        if (Objects.isNull(wkOrder)) {
            throw new CoolException("单据不存在！！");
        }
        List<AsnOrderItem> asnOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>()
                .eq(AsnOrderItem::getAsnCode, map.get("asnCode"))
                .eq(AsnOrderItem::getNtyStatus, 1));
        if (asnOrderItems.isEmpty()) {
        List<WkOrderItem> wkOrderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>()
                .eq(WkOrderItem::getAsnCode, map.get("asnCode"))
                .eq(WkOrderItem::getNtyStatus, 1));
        if (wkOrderItems.isEmpty()) {
            return new ArrayList<>();
        }
        return asnOrderItems;
        return wkOrderItems;
    }

    @Override

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/QlyIsptItemServiceImpl.java

@@ -160,10 +160,10 @@
        Double safeQty = Objects.isNull(item.getSafeQty()) ? 0 : item.getSafeQty();
        Double sum = disQty + safeQty;

        AsnOrderItem asnOrderItem = asnOrderItemService.getById(item.getAsnItemId());
        if (Objects.isNull(asnOrderItem)) {
            if (StringUtils.isNoneBlank(asnOrderItem.getSplrCode())) {
                Companys companys = companysService.getOne(new LambdaQueryWrapper<Companys>().eq(Companys::getCode, asnOrderItem.getSplrCode()));
        WkOrderItem wkOrderItem = asnOrderItemService.getById(item.getAsnItemId());
        if (Objects.isNull(wkOrderItem)) {
            if (StringUtils.isNoneBlank(wkOrderItem.getSplrCode())) {
                Companys companys = companysService.getOne(new LambdaQueryWrapper<Companys>().eq(Companys::getCode, wkOrderItem.getSplrCode()));
                orderItem.setSplrId(companys.getId());
            }
        }

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/TaskServiceImpl.java

@@ -842,7 +842,7 @@
                                throw new CoolException("原单据状态修改失败！！");
                            }

                            AsnOrderItem orderItem = outStockItemService.getById(item.getSource());
                            WkOrderItem orderItem = outStockItemService.getById(item.getSource());
                            if (Objects.isNull(orderItem)) {
                                throw new CoolException("数据错误：单据明细已不存在！！");
                            }
@@ -1063,7 +1063,7 @@
                        throw new CoolException(e.getMessage());
                    }
                } else if (task.getResource().equals(TaskResouceType.TASK_RESOUCE_ORDER_TYPE.val)) {
                    AsnOrderItem orderItem = asnOrderItemService.getById(key);
                    WkOrderItem orderItem = asnOrderItemService.getById(key);
                    if (Objects.isNull(orderItem)) {
                        throw new CoolException("单据明细不存在！！");
                    }
@@ -1125,7 +1125,7 @@
     * @version 1.0
     */
    @Transactional(rollbackFor = Exception.class)
    public void saveOutStockItem(List<TaskItem> taskItems, AsnOrderItem orderItem, WaveItem waveItem, Long loginUserId) throws Exception {
    public void saveOutStockItem(List<TaskItem> taskItems, WkOrderItem orderItem, WaveItem waveItem, Long loginUserId) throws Exception {
        Stock stock = new Stock();
        String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_STOCK_CODE, null);
        if (StringUtils.isBlank(ruleCode)) {

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/WaveOrderRelaServiceImpl.java

@@ -2,11 +2,10 @@

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.entity.AsnOrderItem;
import com.vincent.rsf.server.manager.entity.WkOrderItem;
import com.vincent.rsf.server.manager.mapper.WaveOrderRelaMapper;
import com.vincent.rsf.server.manager.entity.WaveOrderRela;
import com.vincent.rsf.server.manager.service.AsnOrderItemService;
@@ -34,8 +33,8 @@
            return R.ok();
        }
        List<Long> orderIds = orderRelas.stream().map(WaveOrderRela::getOrderItemId).collect(Collectors.toList());
        PageParam<AsnOrderItem, BaseParam> pageParam = new PageParam<>(baseParam, AsnOrderItem.class);
        QueryWrapper<AsnOrderItem> wrapper = pageParam.buildWrapper(true);
        PageParam<WkOrderItem, BaseParam> pageParam = new PageParam<>(baseParam, WkOrderItem.class);
        QueryWrapper<WkOrderItem> wrapper = pageParam.buildWrapper(true);
        wrapper.in("id", orderIds);
        return R.ok().add(asnOrderItemService.page(pageParam, wrapper));
    }

 rsf-server/src/main/java/com/vincent/rsf/server/manager/service/impl/WaveServiceImpl.java

@@ -242,7 +242,7 @@
        }

        List<Long> orderIds = orderRelas.stream().map(WaveOrderRela::getOrderItemId).collect(Collectors.toList());
        List<AsnOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<AsnOrderItem>().in(AsnOrderItem::getId, orderIds));
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().in(WkOrderItem::getId, orderIds));
        orderItems.forEach(asnOrderItem -> {
            asnOrderItem.setWorkQty(0.0);
            if (!asnOrderItemService.updateById(asnOrderItem)) {

 rsf-server/src/main/resources/mapper/manager/AsnOrderItemMapper.xml

@@ -71,7 +71,7 @@
            ) t
        ${ew.customSqlSegment}
    </select>
    <select id="resultById" resultType="com.vincent.rsf.server.manager.entity.AsnOrderItem">
    <select id="resultById" resultType="com.vincent.rsf.server.manager.entity.WkOrderItem">
        SELECT
            *
        FROM