盘点单、入库单、出库单同步接口

skyouc

2 天以前 f84b3af27f34be7e22990c54612f3110559c7710

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

@@ -2,19 +2,27 @@


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.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.vincent.rsf.framework.common.R;
import com.vincent.rsf.framework.exception.CoolException;
import com.vincent.rsf.server.api.controller.erp.params.*;
import com.vincent.rsf.server.common.domain.BaseParam;
import com.vincent.rsf.server.common.domain.PageParam;
import com.vincent.rsf.server.manager.controller.dto.LocStockDto;
import com.vincent.rsf.server.manager.entity.*;
import com.vincent.rsf.server.manager.enums.CompanysType;
import com.vincent.rsf.server.manager.enums.OrderType;
import com.vincent.rsf.server.manager.entity.PurchaseItem;
import com.vincent.rsf.server.manager.service.PurchaseItemService;
import com.vincent.rsf.server.manager.service.PurchaseService;
import com.vincent.rsf.server.manager.enums.OrderWorkType;
import com.vincent.rsf.server.manager.service.*;
import com.vincent.rsf.server.manager.service.impl.MatnrServiceImpl;
import com.vincent.rsf.server.system.constant.SerialRuleCode;
import com.vincent.rsf.server.api.controller.params.OrderParams;
import com.vincent.rsf.server.system.entity.Fields;
import com.vincent.rsf.server.system.service.FieldsItemService;
import com.vincent.rsf.server.system.service.FieldsService;
import com.vincent.rsf.server.system.utils.SerialRuleUtils;
import com.vincent.rsf.server.api.service.ReceiveMsgService;
import com.vincent.rsf.server.manager.entity.Purchase;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
@@ -22,6 +30,7 @@
import org.springframework.transaction.annotation.Transactional;

import java.util.*;
import java.util.stream.Collectors;

/**
 * @author Ryan
@@ -42,7 +51,36 @@
    private FieldsService fieldsService;
    @Autowired
    private FieldsItemService fieldsItemService;
    @Autowired
    private MatnrGroupService matnrGroupService;
    @Autowired
    private MatnrServiceImpl matnrService;
    @Autowired
    private AsnOrderService asnOrderService;
    @Autowired
    private AsnOrderItemService asnOrderItemService;
    @Autowired
    private DeliveryService deliveryService;
    @Autowired
    private DeliveryItemService deliveryItemService;
    @Autowired
    private LocService locService;
    @Autowired
    private LocItemService locItemService;
    @Autowired
    private WarehouseAreasService warehouseAreasService;
    @Autowired
    private WarehouseService warehouseService;
    @Autowired
    private CompanysService companysService;


    /**
     * @author Ryan
     * @date 2025/8/15
     * @description: 保存PO/DO单据
     * @version 1.0
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean syncPurchasee(List<OrderParams> orders) {
@@ -50,35 +88,69 @@
            throw new CoolException("单据内容不能为空！！");
        }
        orders.forEach(ors -> {
            Purchase purchase = new Purchase();
            BeanUtils.copyProperties(ors, purchase);
            String wkVal = SerialRuleUtils.generateRuleCode(SerialRuleCode.PURCHASE_CODE, purchase);
            purchase.setCode(wkVal)
                    .setType(OrderType.ORDER_PURCHASE_IN.type);
            if (!purchaseService.save(purchase)) {
                throw new CoolException("采购单据保存失败");
            }
            if (ors.getType().equals("po")) {
                Purchase purchase = new Purchase();
                BeanUtils.copyProperties(ors, purchase);
                String wkVal = SerialRuleUtils.generateRuleCode(SerialRuleCode.PURCHASE_CODE, purchase);
                purchase.setCode(wkVal)
                        .setType(OrderType.ORDER_IN.type);
                if (!purchaseService.save(purchase)) {
                    throw new CoolException("采购单据保存失败");
                }

            //查询扩展字段是否存在
            List<Fields> fields = fieldsService.list(new LambdaQueryWrapper<Fields>().eq(Fields::getStatus, 1).eq(Fields::getFlagEnable, 1));
                //查询扩展字段是否存在
                List<Fields> fields = fieldsService.list(new LambdaQueryWrapper<Fields>().eq(Fields::getStatus, 1).eq(Fields::getFlagEnable, 1));

            //判断子列表不为空
            if (!ors.getChildren().isEmpty()) {
                ArrayList<PurchaseItem> list = new ArrayList<>();
                ors.getChildren().forEach(orderItem -> {
                    PurchaseItem item = new PurchaseItem();
                    BeanUtils.copyProperties(orderItem, item);
                //判断子列表不为空
                if (!ors.getChildren().isEmpty()) {
                    ArrayList<PurchaseItem> list = new ArrayList<>();
                    ors.getChildren().forEach(orderItem -> {
                        PurchaseItem item = new PurchaseItem();
                        BeanUtils.copyProperties(orderItem, item);
//                    if (!fields.isEmpty()) {
//                        List<String> fieldValue = fields.stream().map(Fields::getFields).collect(Collectors.toList());
//                        fieldValue.forEach(value -> {
//
//                        });
//                    }
                    item.setPurchaseId(purchase.getId());
                    list.add(item);
                });
                if (!purchaseItemService.saveBatch(list)) {
                    throw new CoolException("采购单明细保存失败！！");
                        item.setPurchaseId(purchase.getId());
                        list.add(item);
                    });
                    if (!purchaseItemService.saveBatch(list)) {
                        throw new CoolException("采购单明细保存失败！！");
                    }
                }
            } else {
                Delivery delivery = new Delivery();
                BeanUtils.copyProperties(ors, delivery);
                String wkVal = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_DELIVERY_RULE_CODE, delivery);
                delivery.setCode(wkVal)
                        .setType(OrderType.ORDER_OUT.type);
                if (!deliveryService.save(delivery)) {
                    throw new CoolException("采购单据保存失败");
                }

                //查询扩展字段是否存在
                List<Fields> fields = fieldsService.list(new LambdaQueryWrapper<Fields>().eq(Fields::getStatus, 1).eq(Fields::getFlagEnable, 1));

                //判断子列表不为空
                if (!ors.getChildren().isEmpty()) {
                    ArrayList<DeliveryItem> list = new ArrayList<>();
                    ors.getChildren().forEach(orderItem -> {
                        DeliveryItem item = new DeliveryItem();
                        BeanUtils.copyProperties(orderItem, item);
//                    if (!fields.isEmpty()) {
//                        List<String> fieldValue = fields.stream().map(Fields::getFields).collect(Collectors.toList());
//                        fieldValue.forEach(value -> {
//
//                        });
//                    }
                        item.setDeliveryId(delivery.getId());
                        list.add(item);
                    });
                    if (!deliveryItemService.saveBatch(list)) {
                        throw new CoolException("采购单明细保存失败！！");
                    }
                }
            }
        });
@@ -86,6 +158,257 @@
        return true;
    }

    /**
     * 物料信息同步
     *
     * @param matnrs
     */
    @Override
    public void syncMatnrs(List<BaseMatParms> matnrs) {
        List<Matnr> syncMatnrs = new ArrayList<>();
        if (!matnrs.isEmpty()) {
            matnrs.forEach(matnr -> {
                Matnr mat = new Matnr();
                if (Objects.isNull(matnr.getMatnr())) {
                    throw new RuntimeException("物料编码不能为空！！");
                }
                BeanUtils.copyProperties(matnr, mat);
                mat.setCode(matnr.getMatnr()).setName(matnr.getMaktx());
                if (!Objects.isNull(matnr.getGroupName())) {
                    MatnrGroup matnrGroup = matnrGroupService.getOne(new LambdaQueryWrapper<MatnrGroup>().eq(MatnrGroup::getName, matnr.getGroupName()), false);
                    if (Objects.isNull(matnrGroup)) {
                        mat.setGroupCode(matnrGroup.getCode()).setGroupId(matnrGroup.getId());
                    }
                }
                syncMatnrs.add(mat);
            });

            if (!matnrService.saveOrUpdateBatch(syncMatnrs)) {
                throw new CoolException("物料信息保存成功！！");
            }
        }
    }

    /**
     * @author Ryan
     * @date 2025/8/15
     * @description: 订单查询
     * @version 1.0
     */
    @Override
    public R queryOrderStatus(QueryOrderParam queryParams) {
        WkOrder wkOrders = asnOrderService.getOne(new LambdaQueryWrapper<WkOrder>()
                .eq(WkOrder::getCode, queryParams.getOrderNo())
                .eq(WkOrder::getType, queryParams.getType()));
        if (Objects.isNull(wkOrders)) {
            throw new CoolException("单据不存在！！");
        }
        List<WkOrderItem> orderItems = asnOrderItemService.list(new LambdaQueryWrapper<WkOrderItem>().eq(WkOrderItem::getOrderId, wkOrders.getId()));

        WkOrderDto wkorderDto = new WkOrderDto();
        wkorderDto.setOrder(wkOrders).setOrderItems(orderItems);

        return R.ok().add(wkorderDto);
    }

    /**
     * @author Ryan
     * @date 2025/8/15
     * @description: 查询库位信息
     * @version 1.0
     */
    @Override
    public R syncLocsDetl(PageParam<Loc, BaseParam> pageParam, QueryWrapper<Loc> wrapper) {
        Page<Object> page = new Page<>();
        page.setCurrent(pageParam.getCurrent()).setSize(pageParam.getSize());
        IPage<LocStockDto> locStocks =  locService.getLocDetls(page);
        return R.ok().add(locStocks);
    }

    /**
     * @author Ryan
     * @date 2025/8/18
     * @description: 库位同步
     * @version 1.0
     */
    @Override
    @Transactional(timeout = 60, rollbackFor = Exception.class)
    public R syncLocs(List<SyncLocsParams> locs) {
        List<Loc> syncLocs = new ArrayList<>();
        locs.forEach(loc -> {
            Loc loc1 = new Loc();
            BeanUtils.copyProperties(loc, loc1);
            loc1.setCode(loc.getLocCode()).setId(null);
            syncLocs.add(loc1);
        });
        if (!locService.saveBatch(syncLocs)) {
            throw new CoolException("库位同步失败！！");
        }
        return R.ok();
    }

    /**
     * @author Ryan
     * @date 2025/8/18
     * @description: 物料信息同步
     * @version 1.0
     */
    @Override
    @Transactional(timeout = 60, rollbackFor = Exception.class)
    public R syncMatGroups(List<SyncMatGroupsParams> matGroupsParams) {
        List<MatnrGroup> syncMatGroups = new ArrayList<>();
        matGroupsParams.forEach(matGroupsParam -> {
            MatnrGroup matnrGroup = new MatnrGroup();
            BeanUtils.copyProperties(matGroupsParam, matnrGroup);
            if (Objects.isNull(matGroupsParam.getCode())) {
                throw new CoolException("物料分组编码不能为空！！");
            }
            if (Objects.isNull(matGroupsParam.getName())) {
                throw new CoolException("分组名称不能为空！！");
            }
            if (Objects.isNull(matGroupsParam.getParCode())) {
                throw new CoolException("上级物料分组编码不能为空！！");
            }
            syncMatGroups.add(matnrGroup);
        });
        if (!matnrGroupService.saveBatch(syncMatGroups)) {
            throw new CoolException("物料分组保存失败！！");
        }
        return R.ok();
    }

    /**
     * @author Ryan
     * @date 2025/8/18
     * @description: 库区信息同步
     * @version 1.0
     */
    @Override
    @Transactional(timeout = 60, rollbackFor = Exception.class)
    public R syncWarehouseAreas(List<LocAreasParams> areasParams) {
        areasParams.forEach(param -> {
            WarehouseAreas locArea = new WarehouseAreas();
            BeanUtils.copyProperties(param, locArea);
            WarehouseAreas warehouseAreas = warehouseAreasService
                    .getOne(new LambdaQueryWrapper<WarehouseAreas>()
                    .eq(WarehouseAreas::getName, param.getName()));
            if (!Objects.isNull(warehouseAreas)) {
                locArea.setWarehouseId(warehouseAreas.getId());
            }
            locArea.setName(param.getName())
                    .setCode(param.getCode())
                    .setId(null);
            if (!warehouseAreasService.save(locArea)) {
                throw new CoolException("库区保存失败！！");
            }
        });
        return R.ok();
    }

    /**
     * @author Ryan
     * @date 2025/8/18
     * @description: 仓库同步
     * @version 1.0
     */
    @Override
    @Transactional(timeout = 60, rollbackFor = Exception.class)
    public R syncWarehouse(List<WarehouseParams> warehouses) {
        warehouses.forEach(warehouse -> {
            Warehouse ware = new Warehouse();
            BeanUtils.copyProperties(warehouse, ware);
            ware.setId(null);
            if (!warehouseService.save(ware)) {
                throw new CoolException("仓库同步保存失败！！");
            }
        });
        return R.ok();
    }

    /**
     * @author Ryan
     * @date 2025/8/19
     * @description: 同步企业信息
     * @version 1.0
     */
    @Override
    @Transactional(timeout = 60, rollbackFor = Exception.class)
    public R syncCompanies(List<CompaniesParam> companyParams) {
        companyParams.forEach(param -> {
            Companys companys = new Companys();
            BeanUtils.copyProperties(param, companys);
            if (Objects.isNull(companys.getCode())) {
                throw new CoolException("企业编码不能为空！！");
            }
            Companys one = companysService.getOne(new LambdaQueryWrapper<Companys>().eq(Companys::getName, param.getName()));
            if (Objects.isNull(one)) {
                String ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_COMPANYS_CODE, null);
                companys.setCode(ruleCode);
            } else {
                throw new CoolException(one.getName() +  "，企业名重复！！");
            }
            companys.setType(CompanysType.getCustomVal(param.getType()))
                    .setId(null);
            if (!companysService.save(companys)) {
                throw new CoolException("企业保存失败！！");
            }
        });
        return R.ok();
    }


    @Override
    @Transactional(timeout = 60, rollbackFor = Exception.class)
    public R syncCheckOrder(SyncOrderParams syncOrders, Long loginUserId) {
        List<SyncOrdersItem> ordersItems = syncOrders.getItems();
        Map<String, List<SyncOrdersItem>> listMap = ordersItems.stream().collect(Collectors.groupingBy(SyncOrdersItem::getOrderCode));
        listMap.keySet().forEach(orderCode -> {
            WkOrder wkOrder = new WkOrder();
            String ruleCode = null;
            if (syncOrders.getType().equals(OrderType.ORDER_CHECK.type)) {
                 ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_CHECK_RULE_CODE, null);
            } else if (syncOrders.getType().equals(OrderType.ORDER_IN.type)) {
                ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_ASN_ORDER, null);
            } else if (syncOrders.getType().equals(OrderType.ORDER_OUT.type)) {
                ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_OUT_STOCK_CODE, null);
            }  else if (syncOrders.getType().equals(OrderType.ORDER_REVISE.type)) {
                ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_LOC_REVISE_CODE, null);
            } else if (syncOrders.getType().equals(OrderType.ORDER_TRANSFER.type)) {
                ruleCode = SerialRuleUtils.generateRuleCode(SerialRuleCode.SYS_TRANSFER_ORDER_CODE, null);
            }

            SyncOrdersItem ordersItem = listMap.get(orderCode).stream().findFirst().get();
            Double anfmes = listMap.get(orderCode).stream().mapToDouble(SyncOrdersItem::getAnfme).sum();
            wkOrder.setType(syncOrders.getType())
                    .setWkType(OrderWorkType.getWorkType(ordersItem.getWkType()))
                    .setAnfme(anfmes)
                    .setPoCode(orderCode)
                    .setPoId(ordersItem.getId())
                    .setCode(ruleCode)
                    .setId(null)
                    .setCreateTime(new Date())
                    .setUpdateTime(new Date())
                    .setCreateBy(loginUserId)
                    .setUpdateBy(loginUserId);

            if (!asnOrderService.save(wkOrder)) {
                throw new CoolException("单据保存失败！！");
            }

            listMap.get(orderCode).forEach(order -> {
                WkOrderItem wkOrderItem = new WkOrderItem();
                BeanUtils.copyProperties(order, wkOrderItem);
                wkOrderItem.setOrderCode(wkOrder.getCode())
                        .setOrderId(wkOrder.getId())
                        .setId(null);

                if (!asnOrderItemService.save(wkOrderItem)) {
                    throw new CoolException("单据明细保存失败！！");
                }
            });
        });

        return R.ok();
    }

}