fix: 工艺路线工序参数表取消绑定基础参数表

gongchunyi

9 小时以前 a497406167f500741ac6cc1d24e086589972eb49

 src/main/java/com/ruoyi/appendix/service/impl/AppendixServiceImpl.java

@@ -3,9 +3,9 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.ruoyi.appendix.pojo.ProcessRouteItemInstance;
import com.ruoyi.appendix.pojo.ProcessRouteItemParamInstance;
import com.ruoyi.appendix.pojo.ProductProcessParamInstance;
import com.ruoyi.appendix.pojo.ProductStructureInstance;
import com.ruoyi.appendix.service.*;
import com.ruoyi.basic.service.BaseParamService;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.production.pojo.*;
@@ -16,7 +16,9 @@
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
@@ -39,10 +41,10 @@
    private ProcessRouteItemParamInstanceService processRouteItemParamInstanceService;

    @Resource
    private ProductProcessParamInstanceService productProcessParamInstanceService;
    private ProductStructureInstanceService productStructureInstanceService;

    @Resource
    private ProductStructureInstanceService productStructureInstanceService;
    private BaseParamService baseParamService;

    @Resource
    private ProcessRouteService processRouteService;
@@ -54,16 +56,13 @@
    private ProcessRouteItemParamService processRouteItemParamService;

    @Resource
    private ProductProcessParamService productProcessParamService;

    @Resource
    private ProductStructureService productStructureService;

    @Resource
    private ProductOrderService productOrderService;

    @Override
    public Long populateBlocks(ProductionPlanDto productionPlanDto) {
    public Long populateBlocks(Long orderId, ProductionPlanDto productionPlanDto) {
        if (productionPlanDto == null) {
            throw new ServiceException("下发数据不能为空");
        }
@@ -75,12 +74,12 @@
            log.info("下发产品【{}】未查询出工艺路线", productionPlanDto.getProductName());
            return null;
        }
        migration(processRoute);
        migration(orderId, processRoute);
        return processRoute.getId();
    }

    @Override
    public Long populatePlates(ProductionPlanDto productionPlanDto) {
    public Long populatePlates(Long orderId, ProductionPlanDto productionPlanDto) {
        if (productionPlanDto == null) {
            throw new ServiceException("下发数据不能为空");
        }
@@ -90,127 +89,141 @@
            log.info("下发产品【{}】未查询出工艺路线", productionPlanDto.getProductName());
            return null;
        }
        migration(processRoute);
        migration(orderId, processRoute);
        return processRoute.getId();
    }

    @Override
    public void populateData(Long productOrderId, Long processRouteId) {
        ProcessRoute processRoute = processRouteService.getById(processRouteId);
        if (processRoute == null) {
            log.info("生产订单【{}】未查询出工艺路线【{}】", productOrderId, processRouteId);
            return;
    public void populateData(ProductOrder productOrder) {
        if (productOrder == null) {
            throw new ServiceException("绑定失败.数据不能为空");
        }
        migration(processRoute);
        if (productOrder.getId() == null || productOrder.getRouteId() == null) {
            throw new ServiceException("绑定失败,生产订单或工艺路线不能为空");
        }
        ProcessRoute processRoute = processRouteService.getById(productOrder.getRouteId());
        if (processRoute == null) {
            throw new ServiceException("该工艺路线不存在,绑定失败");
        }
        migration(productOrder.getId(), processRoute);

        //  回写工艺路线id到生产订单
        ProductOrder productOrder = new ProductOrder();
        productOrder.setId(productOrderId);
        productOrder.setRouteId(processRouteId);
        productOrderService.updateById(productOrder);
    }

    @Override
    public void deleteData(Long processRouteId) {
        //  查出工艺路线子集，用于关联删除参数附表
        List<ProcessRouteItem> itemList = processRouteItemService.list(new LambdaQueryWrapper<ProcessRouteItem>().eq(ProcessRouteItem::getRouteId, processRouteId));

        if (itemList != null && !itemList.isEmpty()) {
            List<Long> itemIds = itemList.stream().map(ProcessRouteItem::getId).collect(Collectors.toList());
            List<Long> processIds = itemList.stream().map(ProcessRouteItem::getProcessId).collect(Collectors.toList());

            //  删除工艺路线工序参数附表
            processRouteItemParamInstanceService.remove(new LambdaQueryWrapper<ProcessRouteItemParamInstance>().in(ProcessRouteItemParamInstance::getRouteItemId, itemIds));

            //  删除工序绑定参数附表
            productProcessParamInstanceService.remove(new LambdaQueryWrapper<ProductProcessParamInstance>().in(ProductProcessParamInstance::getProcessId, processIds));
        }
    public void deleteData(Long orderId, Long processRouteId) {
        //  删除工艺路线工序参数附表
        processRouteItemParamInstanceService.remove(new LambdaQueryWrapper<ProcessRouteItemParamInstance>()
                .eq(ProcessRouteItemParamInstance::getOrderId, orderId));

        //  删除工艺路线子集附表
        processRouteItemInstanceService.remove(
                new LambdaQueryWrapper<ProcessRouteItemInstance>().eq(ProcessRouteItemInstance::getRouteId, processRouteId));
        processRouteItemInstanceService.remove(new LambdaQueryWrapper<ProcessRouteItemInstance>()
                .eq(ProcessRouteItemInstance::getOrderId, orderId)
                .eq(ProcessRouteItemInstance::getRouteId, processRouteId));

        //  删除BOM子集附表
        ProcessRoute processRoute = processRouteService.getById(processRouteId);
        if (processRoute != null && processRoute.getBomId() != null) {
            productStructureInstanceService.remove(new LambdaQueryWrapper<ProductStructureInstance>().eq(ProductStructureInstance::getBomId, processRoute.getBomId()));
            productStructureInstanceService.remove(new LambdaQueryWrapper<ProductStructureInstance>()
                    .eq(ProductStructureInstance::getOrderId, orderId)
                    .eq(ProductStructureInstance::getBomId, processRoute.getBomId()));
        }
    }

    /**
     * 根据工艺路线迁移四张附表数据
     * 根据工艺路线迁移附表数据
     */
    private void migration(ProcessRoute processRoute) {
        //  迁移工艺路线子集表数据
        List<ProcessRouteItem> processRouteItemList = processRouteItemService.list(new LambdaQueryWrapper<ProcessRouteItem>().eq(ProcessRouteItem::getRouteId, processRoute.getId()));
        migrationProcessRouteItem(processRouteItemList);
    private void migration(Long orderId, ProcessRoute processRoute) {
        //  迁移工艺路线子集表数据，返回旧id->新instance映射
        List<ProcessRouteItem> processRouteItemList = processRouteItemService.list(
                new LambdaQueryWrapper<ProcessRouteItem>().eq(ProcessRouteItem::getRouteId, processRoute.getId()));
        Map<Long, ProcessRouteItemInstance> routeItemOldIdMap = migrationProcessRouteItem(orderId, processRouteItemList);

        //  迁移工艺路线内绑定的工序及工序参数
        //  迁移工艺路线内绑定的工序参数
        if (processRouteItemList != null && !processRouteItemList.isEmpty()) {
            for (ProcessRouteItem item : processRouteItemList) {
                List<ProcessRouteItemParam> paramList = processRouteItemParamService.list(new LambdaQueryWrapper<ProcessRouteItemParam>().eq(ProcessRouteItemParam::getRouteItemId, item.getId()));
                migrationProcessRouteItemParam(paramList);
                ProcessRouteItemInstance newInstance = routeItemOldIdMap.get(item.getId());
                Long newRouteItemInstanceId = newInstance != null ? newInstance.getId() : item.getId();

                List<ProductProcessParam> processParamList = productProcessParamService.list(new LambdaQueryWrapper<ProductProcessParam>().eq(ProductProcessParam::getProcessId, item.getProcessId()));
                migrationProductProcessParam(processParamList);
                List<ProcessRouteItemParam> paramList = processRouteItemParamService.list(
                        new LambdaQueryWrapper<ProcessRouteItemParam>().eq(ProcessRouteItemParam::getRouteItemId, item.getId()));
                migrationProcessRouteItemParam(orderId, paramList, newRouteItemInstanceId);
            }
        }

        //  迁移BOM子集表数据
        if (processRoute.getBomId() != null) {
            List<ProductStructure> structureList = productStructureService.list(new LambdaQueryWrapper<ProductStructure>().eq(ProductStructure::getBomId, processRoute.getBomId()));
            migrationProductStructure(structureList);
            List<ProductStructure> structureList = productStructureService.list(
                    new LambdaQueryWrapper<ProductStructure>().eq(ProductStructure::getBomId, processRoute.getBomId()));
            migrationProductStructure(orderId, structureList);
        }
    }

    private void migrationProcessRouteItem(List<ProcessRouteItem> list) {
    private Map<Long, ProcessRouteItemInstance> migrationProcessRouteItem(Long orderId, List<ProcessRouteItem> list) {
        Map<Long, ProcessRouteItemInstance> oldIdMap = new HashMap<>();
        if (list == null || list.isEmpty()) {
            return;
            return oldIdMap;
        }
        List<ProcessRouteItemInstance> instances = list.stream().map(item -> {
            ProcessRouteItemInstance instance = new ProcessRouteItemInstance();
            BeanUtils.copyProperties(item, instance, "id");
            instance.setIsQuality(item.getIsQuality() != null && item.getIsQuality() ? 1 : 0);
            instance.setOrderId(orderId);
            if (item.getId() != null) {
                oldIdMap.put(item.getId(), instance);
            }
            return instance;
        }).collect(Collectors.toList());
        processRouteItemInstanceService.saveBatch(instances);
        return oldIdMap;
    }

    private void migrationProcessRouteItemParam(List<ProcessRouteItemParam> list) {
    private void migrationProcessRouteItemParam(Long orderId, List<ProcessRouteItemParam> list, Long newRouteItemInstanceId) {
        if (list == null || list.isEmpty()) {
            return;
        }
        List<ProcessRouteItemParamInstance> instances = list.stream().map(item -> {
            ProcessRouteItemParamInstance instance = new ProcessRouteItemParamInstance();
            BeanUtils.copyProperties(item, instance, "id");
            instance.setOrderId(orderId);
            instance.setRouteItemId(newRouteItemInstanceId);
            return instance;
        }).collect(Collectors.toList());
        processRouteItemParamInstanceService.saveBatch(instances);
    }

    private void migrationProductProcessParam(List<ProductProcessParam> list) {
    private void migrationProductStructure(Long orderId, List<ProductStructure> list) {
        if (list == null || list.isEmpty()) {
            return;
        }
        List<ProductProcessParamInstance> instances = list.stream().map(item -> {
            ProductProcessParamInstance instance = new ProductProcessParamInstance();
            BeanUtils.copyProperties(item, instance, "id");
            instance.setIsRequired(item.getIsRequired() != null && item.getIsRequired() == 1);
            return instance;
        }).collect(Collectors.toList());
        productProcessParamInstanceService.saveBatch(instances);
    }

    private void migrationProductStructure(List<ProductStructure> list) {
        if (list == null || list.isEmpty()) {
            return;
        }
        Map<Long, ProductStructureInstance> oldIdMap = new HashMap<>();
        List<ProductStructureInstance> instances = list.stream().map(item -> {
            ProductStructureInstance instance = new ProductStructureInstance();
            BeanUtils.copyProperties(item, instance, "id");
            instance.setBomId(item.getBomId() != null ? item.getBomId().longValue() : null);
            instance.setOrderId(orderId);
            if (item.getId() != null) {
                oldIdMap.put(item.getId(), instance);
            }
            return instance;
        }).collect(Collectors.toList());
        productStructureInstanceService.saveBatch(instances);

        //  新增后有id，旧id->新id，修正parentId
        Map<Long, Long> oldToNewId = new HashMap<>();
        list.forEach(item -> {
            if (item.getId() != null && oldIdMap.containsKey(item.getId())) {
                oldToNewId.put(item.getId(), oldIdMap.get(item.getId()).getId());
            }
        });

        List<ProductStructureInstance> toUpdate = instances.stream()
                .filter(i -> i.getParentId() != null && oldToNewId.containsKey(i.getParentId()))
                .peek(i -> i.setParentId(oldToNewId.get(i.getParentId())))
                .collect(Collectors.toList());
        if (!toUpdate.isEmpty()) {
            productStructureInstanceService.updateBatchById(toUpdate);
        }
    }
}