fix: 移除数据同步类型，修改数据来源方式

gongchunyi

昨天 843d20d3b513c3513b77cfd623368571f9345e3c

 src/main/java/com/ruoyi/productionPlan/service/impl/ProductionPlanServiceImpl.java

@@ -1,11 +1,51 @@
package com.ruoyi.productionPlan.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.common.utils.http.HttpUtils;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.framework.config.AliDingConfig;
import com.ruoyi.production.pojo.ProductMaterial;
import com.ruoyi.production.pojo.ProductMaterialSku;
import com.ruoyi.production.pojo.ProductOrder;
import com.ruoyi.production.service.ProductMaterialService;
import com.ruoyi.production.service.ProductMaterialSkuService;
import com.ruoyi.production.service.ProductOrderService;
import com.ruoyi.productionPlan.dto.ProductionPlanDto;
import com.ruoyi.productionPlan.dto.ProductionPlanImportDto;
import com.ruoyi.productionPlan.dto.ProductionPlanSummaryDto;
import com.ruoyi.productionPlan.enums.DataSourceTypeEnum;
import com.ruoyi.productionPlan.mapper.ProductOrderPlanMapper;
import com.ruoyi.productionPlan.mapper.ProductionPlanMapper;
import com.ruoyi.productionPlan.pojo.ProductOrderPlan;
import com.ruoyi.productionPlan.pojo.ProductionPlan;
import com.ruoyi.productionPlan.service.ProductionPlanService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletResponse;
import java.math.BigDecimal;
import java.nio.charset.StandardCharsets;
import java.time.*;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.*;
import java.util.concurrent.locks.ReentrantLock;
import java.util.stream.Collectors;


/**
 * <br>
@@ -20,4 +60,531 @@
@Slf4j
@Service
public class ProductionPlanServiceImpl extends ServiceImpl<ProductionPlanMapper, ProductionPlan> implements ProductionPlanService {

    @Autowired
    private AliDingConfig aliDingConfig;

    @Autowired
    private ProductionPlanMapper productionPlanMapper;

    @Autowired
    private ProductOrderService productOrderService;

    @Autowired
    private ProductOrderPlanMapper productOrderPlanMapper;

    @Autowired
    private ProductMaterialSkuService productMaterialSkuService;

    @Autowired
    private ProductMaterialService productMaterialService;

    /**
     * 同步锁，确保手动和定时任务不同时执行
     */
    private final ReentrantLock syncLock = new ReentrantLock();

    @Override
    public IPage<ProductionPlanDto> listPage(Page page, ProductionPlanDto productionPlanDto) {
        return productionPlanMapper.listPage(page, productionPlanDto);
    }

    /**
     * 页面手动同步
     */
    @Override
    public void loadProdData() {
        syncProdData(1);
    }

    /**
     * 定时任务同步
     */
    @Override
    public void syncProdDataJob() {
        syncProdData(2);
    }

    /**
     * 合并生产计划
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean combine(ProductionPlanDto productionPlanDto) {
        if (productionPlanDto.getIds() == null || productionPlanDto.getIds().isEmpty()) {
            return false;
        }

        //  查询主生产计划
        List<ProductionPlanDto> plans = productionPlanMapper.selectWithMaterialByIds(productionPlanDto.getIds());

        //  校验是否存在不同的产品名称
        String firstProductName = plans.get(0).getProductName();
        if (plans.stream().anyMatch(p -> !p.getProductName().equals(firstProductName))) {
            throw new BaseException("合并失败，存在不同的产品名称");
        }

        // 校验是否存在不同的产品规格
        String firstProductSpec = plans.get(0).getSpecification();
        if (plans.stream().anyMatch(p -> !p.getSpecification().equals(firstProductSpec))) {
            throw new BaseException("合并失败，存在不同的产品规格");
        }

        // 叠加剩余方数
        BigDecimal totalRemainingVolume = plans.stream()
                .map(ProductionPlan::getRemainingVolume)
                .filter(v -> v != null)
                .reduce(BigDecimal.ZERO, BigDecimal::add);
        // 判断下发数量是否大于等于剩余方数
        if (productionPlanDto.getTotalAssignedQuantity().compareTo(totalRemainingVolume) > 0) {
            throw new BaseException("操作失败，下发数量不能大于剩余方数");
        }

        // 创建生产订单
        ProductOrder productOrder = new ProductOrder();
        productOrder.setQuantity(productionPlanDto.getTotalAssignedQuantity());
        productOrder.setPlanCompleteTime(productionPlanDto.getPlanCompleteTime());
        productOrderService.addProductOrder(productOrder);

        // 根据下发数量，从第一个生产计划开始分配方数
        BigDecimal assignedVolume = BigDecimal.ZERO;
        for (ProductionPlan plan : plans) {
            BigDecimal volume = plan.getVolume();
            if (volume == null) {
                continue;
            }
            // 计算剩余方数
            BigDecimal remainingVolume = plan.getRemainingVolume();
            if (remainingVolume.compareTo(BigDecimal.ZERO) <= 0) {
                continue;
            }

            ProductOrderPlan productOrderPlan = new ProductOrderPlan();
            productOrderPlan.setProductOrderId(productOrder.getId());
            productOrderPlan.setProductionPlanId(plan.getId());

            if (assignedVolume.add(remainingVolume).compareTo(productionPlanDto.getTotalAssignedQuantity()) >= 0) {
                // 最后一个计划，分配剩余方数
                BigDecimal lastRemainingVolume = productionPlanDto.getTotalAssignedQuantity().subtract(assignedVolume);
                plan.setStatus(1);
                plan.setAssignedQuantity(plan.getAssignedQuantity().add(lastRemainingVolume));
                productOrderPlan.setAssignedQuantity(lastRemainingVolume);
                productionPlanMapper.updateById(plan);
                productOrderPlanMapper.insert(productOrderPlan);
                break;
            }

            // 分配当前计划方数
            plan.setStatus(1);
            plan.setAssignedQuantity(plan.getAssignedQuantity().add(remainingVolume));
            productOrderPlan.setAssignedQuantity(remainingVolume);
            // 更新生产计划
            productionPlanMapper.updateById(plan);
            // 创建关联关系
            productOrderPlanMapper.insert(productOrderPlan);
            assignedVolume = assignedVolume.add(remainingVolume);
        }
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean add(ProductionPlanDto productionPlanDto) {
        productionPlanDto.setDataSourceType(DataSourceTypeEnum.MANUAL.getCode());
        productionPlanMapper.insert(productionPlanDto);
        return true;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean update(ProductionPlanDto productionPlanDto) {
        // 已下发状态，不能编辑
        if (productionPlanDto.getStatus() == 1) {
            throw new BaseException("已下发状态，不能编辑");
        }
        // 查询是否有关联订单
        boolean hasProductOrderPlan = productOrderPlanMapper.selectList(Wrappers.<ProductOrderPlan>lambdaQuery().eq(ProductOrderPlan::getProductionPlanId, productionPlanDto.getId())).stream().anyMatch(p -> p.getProductOrderId() != null);
        if (hasProductOrderPlan) {
            //  如果关联，方数只能递增
            ProductionPlan currentPlan = productionPlanMapper.selectById(productionPlanDto.getId());
            if (productionPlanDto.getVolume().compareTo(currentPlan.getVolume()) < 0) {
                throw new BaseException("方数不能递减");
            }
        }

        return productionPlanMapper.updateById(productionPlanDto) > 0;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean delete(List<Long> ids) {
        // 如果存在已下发的计划，则不能删除
        if (productionPlanMapper.selectList(Wrappers.<ProductionPlan>lambdaQuery().in(ProductionPlan::getId, ids).eq(ProductionPlan::getStatus, 1)).stream().anyMatch(p -> p.getStatus() == 1)) {
            throw new BaseException("删除失败，存在已下发的计划");
        }
        // 如果有关联订单，则不能删除
        if (productOrderPlanMapper.selectList(Wrappers.<ProductOrderPlan>lambdaQuery().in(ProductOrderPlan::getProductionPlanId, ids)).stream().anyMatch(p -> p.getProductOrderId() != null)) {
            throw new BaseException("删除失败，存在关联订单");
        }

        return productionPlanMapper.deleteBatchIds(ids) > 0;
    }

    /**
     * 同步数据
     */
    @Transactional(rollbackFor = Exception.class)
    public void syncProdData(Integer dataSyncType) {
        if (!syncLock.tryLock()) {
            log.warn("同步正在进行中，本次 {} 同步请求被跳过", dataSyncType == 1 ? "手动同步" : "定时任务同步");
            return;
        }

        try {
            //  获取 AccessToken
            String accessToken = getAccessToken();
            if (StringUtils.isEmpty(accessToken)) {
                return;
            }

            //  获取本地最后同步时间
            LocalDateTime lastSyncTime = getLastSyncTime();
            log.info("开始增量同步，本地最后修改时间: {}", lastSyncTime);

            int pageNumber = 1;
            int pageSize = 50;
            boolean hasMore = true;
            int totalSynced = 0;

            while (hasMore) {
                //  查询参数
                JSONObject searchParam = buildSearchParam(lastSyncTime, pageNumber, pageSize);

                //  调用宜搭接口拉取数据
                String dataRes = HttpUtils.sendPostJson(
                        aliDingConfig.getSearchFormDataUrl(),
                        searchParam.toJSONString(),
                        StandardCharsets.UTF_8.name(),
                        null,
                        accessToken
                );

                if (StringUtils.isEmpty(dataRes)) {
                    log.warn("第 {} 页拉取数据为空", pageNumber);
                    break;
                }

                JSONObject resultObj = JSON.parseObject(dataRes);
                JSONArray dataArr = resultObj.getJSONArray("data");
                Integer totalCount = resultObj.getInteger("totalCount");

                if (dataArr == null || dataArr.isEmpty()) {
                    log.info("没有更多新数据需要同步");
                    break;
                }

                //  解析并保存数据
                List<ProductionPlan> list = parseProductionPlans(dataArr, dataSyncType, totalCount);
                if (!list.isEmpty()) {
                    //  处理更新或新增
                    int affected = processSaveOrUpdate(list);
                    totalSynced += affected;
                }

                //  判断是否还有下一页
                hasMore = (pageNumber * pageSize) < totalCount;
                pageNumber++;

                log.info("正在同步第 {} 页，当前已同步 {}/{}", pageNumber - 1, totalSynced, totalCount);
            }

            log.info("数据同步完成，共同步 {} 条数据", totalSynced);
        } catch (Exception e) {
            log.error("同步生产计划异常", e);
        } finally {
            // 释放锁
            syncLock.unlock();
        }
    }

    private String getAccessToken() {
        String params = "appkey=" + aliDingConfig.getAppKey()
                + "&appsecret=" + aliDingConfig.getAppSecret();
        String tokenRes = HttpUtils.sendGet(aliDingConfig.getAccessTokenUrl(), params);
        JSONObject tokenObj = JSON.parseObject(tokenRes);
        String accessToken = tokenObj.getString("access_token");
        if (StringUtils.isEmpty(accessToken)) {
            log.error("获取钉钉AccessToken失败: {}", tokenRes);
        }
        return accessToken;
    }

    private LocalDateTime getLastSyncTime() {
        // 查询本地数据库中 formModifiedTime 最大的记录
        LambdaQueryWrapper<ProductionPlan> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.orderByDesc(ProductionPlan::getFormModifiedTime).last("LIMIT 1");
        ProductionPlan lastRecord = this.getOne(queryWrapper);
        return lastRecord != null ? lastRecord.getFormModifiedTime() : null;
    }

    private JSONObject buildSearchParam(LocalDateTime lastSyncTime, int pageNumber, int pageSize) {
        JSONObject searchParam = new JSONObject();
        searchParam.put("appType", aliDingConfig.getAppType());
        searchParam.put("systemToken", aliDingConfig.getSystemToken());
        searchParam.put("userId", aliDingConfig.getUserId());
        searchParam.put("formUuid", aliDingConfig.getProducePlanFormUuid());
        searchParam.put("currentPage", pageNumber);
        searchParam.put("pageSize", pageSize);

        JSONArray searchConditions = new JSONArray();
        JSONObject condition = new JSONObject();
        condition.put("key", "processApprovedResult");
        JSONArray valueArray = new JSONArray();
        valueArray.add("agree");

        condition.put("value", valueArray);
        condition.put("type", "ARRAY");
        condition.put("operator", "in");
        condition.put("componentName", "SelectField");
        searchConditions.add(condition);

        searchParam.put("searchFieldJson", searchConditions.toJSONString());

        // 默认按修改时间升序排序，确保分页拉取数据的连续性
        // "+" 表示升序，"gmt_modified" 是官方内置字段
        searchParam.put("orderConfigJson", "{\"gmt_modified\":\"+\"}");

        // 设置修改时间筛选区间 (格式必须为yyyy-MM-dd HH:mm:ss)
        if (lastSyncTime != null) {
            // 起始时间：上次同步到的最后一条数据的修改时间
            String startTime = lastSyncTime.plusSeconds(1).atZone(ZoneId.systemDefault())
                    .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
            searchParam.put("modifiedFromTimeGMT", startTime);
        }

        // 截止时间：当前时间，确保获取最新的已修改/已新增数据
        String endTime = LocalDateTime.now().atZone(ZoneId.systemDefault())
                .format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        searchParam.put("modifiedToTimeGMT", endTime);

        return searchParam;
    }

    private List<ProductionPlan> parseProductionPlans(JSONArray dataArr, Integer dataSyncType, Integer totalCount) {
        List<ProductionPlan> list = new ArrayList<>();
        LocalDateTime now = LocalDateTime.now();

        for (int i = 0; i < dataArr.size(); i++) {
            JSONObject item = dataArr.getJSONObject(i);
            String formInstanceId = item.getString("formInstanceId");
            String serialNo = item.getString("serialNo");

            JSONObject originator = item.getJSONObject("originator");
            String originatorName = originator != null && originator.containsKey("userName")
                    ? originator.getJSONObject("userName").getString("nameInChinese") : "未知";

            JSONObject formData = item.getJSONObject("formData");
            JSONArray tableArr = formData.getJSONArray("tableField_l7fytfcn");
            if (tableArr == null || tableArr.isEmpty()) {
                continue;
            }

            for (int j = 0; j < tableArr.size(); j++) {
                JSONObject row = tableArr.getJSONObject(j);
                ProductionPlan plan = new ProductionPlan();

                plan.setFormInstanceId(formInstanceId);
                plan.setSerialNo(serialNo);
                plan.setApplyNo(formData.getString("textField_l7fytfco"));
                plan.setCustomerName(formData.getString("textField_lbkozohg"));

                String materialCode = row.getString("textField_l9xo62q5");
                // 根据物料编码查询物料信息表，关联物料ID
                if (StringUtils.isNotEmpty(materialCode)) {
                    LambdaQueryWrapper<ProductMaterialSku> skuQueryWrapper = new LambdaQueryWrapper<>();
                    skuQueryWrapper.eq(ProductMaterialSku::getMaterialCode, materialCode);
                    ProductMaterialSku sku = productMaterialSkuService.getOne(skuQueryWrapper);
                    if (sku != null) {
                        plan.setProductMaterialSkuId(sku.getId());
                    }
                }

                plan.setLength(row.getInteger("numberField_lb7lgatg_value"));
                plan.setWidth(row.getInteger("numberField_lb7lgath_value"));
                plan.setHeight(row.getInteger("numberField_lb7lgati_value"));
                plan.setQuantity(row.getInteger("numberField_lb7lgatj_value"));
                plan.setVolume(row.getBigDecimal("numberField_l7fytfd3_value"));
                plan.setStrength(row.getString("radioField_m9urarr2_id"));

                JSONArray dateArr = row.getJSONArray("cascadeDateField_lfxqqluw");
                if (dateArr != null && dateArr.size() == 2) {
                    try {
                        long start = Long.parseLong(dateArr.getString(0));
                        long end = Long.parseLong(dateArr.getString(1));

                        Date startDate = Date.from(Instant.ofEpochMilli(start)
                                .atZone(ZoneId.systemDefault())
                                .toLocalDate()
                                .atStartOfDay(ZoneId.systemDefault())
                                .toInstant());
                        Date endDate = Date.from(Instant.ofEpochMilli(end)
                                .atZone(ZoneId.systemDefault())
                                .toLocalDate()
                                .atStartOfDay(ZoneId.systemDefault())
                                .toInstant());

                        plan.setStartDate(startDate);
                        plan.setEndDate(endDate);
                    } catch (Exception e) {
                        log.warn("解析日期失败: {}", dateArr);
                    }
                }

                plan.setSubmitter(originatorName);
                plan.setSubmitOrg("宁夏中创绿能实业集团有限公司");
                plan.setRemarkOne(formData.getString("textareaField_l7fytfcy"));
                plan.setRemarkTwo(formData.getString("textField_l7fytfcx"));
                plan.setCreatorName(originatorName);

                JSONObject modifyUser = item.getJSONObject("modifyUser");
                if (modifyUser != null && modifyUser.containsKey("userName")) {
                    plan.setModifierName(modifyUser.getJSONObject("userName").getString("nameInChinese"));
                }

                plan.setFormCreatedTime(parseUtcTime(item.getString("createdTimeGMT")));
                plan.setFormModifiedTime(parseUtcTime(item.getString("modifiedTimeGMT")));
                plan.setDataSourceType(DataSourceTypeEnum.DING_TALK.getCode());
                plan.setCreateTime(now);
                plan.setUpdateTime(now);
                plan.setTotalCount(totalCount);

                list.add(plan);
            }
        }
        return list;
    }

    private int processSaveOrUpdate(List<ProductionPlan> list) {
        if (list == null || list.isEmpty()) {
            return 0;
        }
        int affected = 0;

        //  去重 formInstanceId
        Set<String> formIds = list.stream()
                .map(ProductionPlan::getFormInstanceId)
                .collect(Collectors.toSet());

        //  查询数据库已有数据
        List<ProductionPlan> existList = this.list(new LambdaQueryWrapper<ProductionPlan>().in(ProductionPlan::getFormInstanceId, formIds));

        //  Map (formInstanceId + materialCode)
        Map<String, ProductionPlan> existMap = new HashMap<>();
        for (ProductionPlan p : existList) {
            String key = p.getFormInstanceId() + "_" + p.getProductMaterialSkuId();
            existMap.put(key, p);
        }

        //  遍历同步数据
        for (ProductionPlan plan : list) {
            String key = plan.getFormInstanceId() + "_" + plan.getProductMaterialSkuId();
            ProductionPlan exist = existMap.get(key);
            if (exist == null) {
                // 新增
                this.save(plan);
                affected++;
                log.info("新增数据 formInstanceId={}, materialCode={}", plan.getFormInstanceId(), plan.getProductMaterialSkuId());
            } else {
                // 判断是否需要更新
                if (exist.getFormModifiedTime() == null || !exist.getFormModifiedTime().equals(plan.getFormModifiedTime())) {
                    plan.setId(exist.getId());
                    plan.setCreateTime(exist.getCreateTime());
                    this.updateById(plan);
                    affected++;
                    log.info("更新数据 formInstanceId={}, materialCode={}", plan.getFormInstanceId(), plan.getProductMaterialSkuId());
                }
            }
        }
        return affected;
    }

    private LocalDateTime parseUtcTime(String utcString) {
        if (StringUtils.isEmpty(utcString)) {
            return null;
        }
        try {
            OffsetDateTime odt = OffsetDateTime.parse(utcString);
            return odt.toLocalDateTime();
        } catch (DateTimeParseException ex) {
            log.warn("解析时间 {} 失败: {}", utcString, ex.getMessage());
            return null;
        }
    }

    @Override
    public List<ProductionPlanSummaryDto> summaryByProductType(ProductionPlanSummaryDto query) {
        return baseMapper.selectSummaryByProductType(query);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void importProdData(MultipartFile file) {
        if (file == null || file.isEmpty()) {
            throw new ServiceException("导入数据不能为空");
        }
        ExcelUtil<ProductionPlanImportDto> excelUtil = new ExcelUtil<>(ProductionPlanImportDto.class);
        List<ProductionPlanImportDto> list;
        try {
            list = excelUtil.importExcel(file.getInputStream());
        } catch (Exception e) {
            log.error("生产需求Excel导入失败", e);
            throw new ServiceException("Excel解析失败");
        }

        if (list == null || list.isEmpty()) {
            throw new ServiceException("Excel没有数据");
        }
        List<ProductionPlan> entityList = new ArrayList<>(list.size());
        ProductionPlan entity;
        for (ProductionPlanImportDto dto : list) {
            entity = new ProductionPlan();
            BeanUtils.copyProperties(dto, entity);
            entity.setAssignedQuantity(BigDecimal.ZERO);
            entity.setCreateTime(LocalDateTime.now());
            entity.setUpdateTime(LocalDateTime.now());
            entity.setDataSourceType(DataSourceTypeEnum.DING_TALK.getCode());

            // 根据物料编码填充关联ID
            if (StringUtils.isNotEmpty(dto.getMaterialCode())) {
                LambdaQueryWrapper<ProductMaterialSku> skuQueryWrapper = new LambdaQueryWrapper<>();
                skuQueryWrapper.eq(ProductMaterialSku::getMaterialCode, dto.getMaterialCode());
                ProductMaterialSku sku = productMaterialSkuService.getOne(skuQueryWrapper);
                if (sku != null) {
                    entity.setProductMaterialSkuId(sku.getId());
                }
            }

            entityList.add(entity);
        }
        this.saveBatch(entityList);
    }

    @Override
    public void exportProdData(HttpServletResponse response, List<Long> ids) {
        List<ProductionPlan> list;
        if (ids != null && !ids.isEmpty()) {
            list = baseMapper.selectBatchIds(ids);
        } else {
            list = baseMapper.selectList(null);
        }

        List<ProductionPlanImportDto> exportList = new ArrayList<>();
        for (ProductionPlan entity : list) {
            ProductionPlanImportDto dto = new ProductionPlanImportDto();
            BeanUtils.copyProperties(entity, dto);
            exportList.add(dto);
        }
        ExcelUtil<ProductionPlanImportDto> util = new ExcelUtil<>(ProductionPlanImportDto.class);
        util.exportExcel(response, exportList, "销售生产需求数据");
    }
}