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

skyouc

2 天以前 f84b3af27f34be7e22990c54612f3110559c7710

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

@@ -7,18 +7,17 @@
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.BaseMatParms;
import com.vincent.rsf.server.api.controller.erp.params.QueryOrderParam;
import com.vincent.rsf.server.api.controller.erp.params.WkOrderDto;
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.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.erp.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;
@@ -31,6 +30,7 @@
import org.springframework.transaction.annotation.Transactional;

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

/**
 * @author Ryan
@@ -67,6 +67,13 @@
    private LocService locService;
    @Autowired
    private LocItemService locItemService;
    @Autowired
    private WarehouseAreasService warehouseAreasService;
    @Autowired
    private WarehouseService warehouseService;
    @Autowired
    private CompanysService companysService;


    /**
     * @author Ryan
@@ -207,7 +214,7 @@
    /**
     * @author Ryan
     * @date 2025/8/15
     * @description: 同步库位信息
     * @description: 查询库位信息
     * @version 1.0
     */
    @Override
@@ -218,5 +225,190 @@
        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();
    }

}