1.初始化配煤计算器数据 2。配煤到待入库

liding

10 小时以前 94509204d25f7c0ad213ae2322be2bd5bfd17424

 main-business/src/main/java/com/ruoyi/business/service/impl/PendingInventoryServiceImpl.java

@@ -6,32 +6,50 @@
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mchange.v2.lang.SystemUtils;
import com.ruoyi.basic.dto.CoalFieldDto;
import com.ruoyi.basic.entity.CoalField;
import com.ruoyi.basic.entity.CoalInfo;
import com.ruoyi.basic.entity.CoalPlan;
import com.ruoyi.basic.entity.CoalValue;
import com.ruoyi.basic.mapper.CoalFieldMapper;
import com.ruoyi.basic.mapper.CoalInfoMapper;
import com.ruoyi.basic.mapper.CoalPlanMapper;
import com.ruoyi.basic.mapper.CoalValueMapper;
import com.ruoyi.basic.service.CoalFieldService;
import com.ruoyi.basic.service.CoalPlanService;
import com.ruoyi.basic.service.CoalValueService;
import com.ruoyi.business.dto.PendingInventoryDto;
import com.ruoyi.business.entity.OfficialInventory;
import com.ruoyi.business.entity.PendingInventory;
import com.ruoyi.business.entity.SalesRecord;
import com.ruoyi.business.mapper.InventorySummaryMapper;
import com.ruoyi.business.mapper.OfficialInventoryMapper;
import com.ruoyi.business.mapper.PendingInventoryMapper;
import com.ruoyi.business.mapper.SalesRecordMapper;
import com.ruoyi.business.service.InputInventoryRecordService;
import com.ruoyi.business.service.InventorySummaryService;
import com.ruoyi.business.service.PendingInventoryService;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.exception.base.BaseException;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.bean.BeanUtils;
import com.ruoyi.system.mapper.SysUserMapper;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.LocalDate;
import java.time.format.DateTimeParseException;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * <p>
@@ -60,11 +78,34 @@
    private final InputInventoryRecordService inputInventoryRecordService;

    private final InventorySummaryService inventorySummaryService;
    private final CoalPlanMapper coalPlanMapper;
    private final CoalValueService coalValueService;

    @Override
    public IPage<PendingInventoryDto> selectPendingInventoryList(Page page, PendingInventoryDto pendingInventoryDto) {
        // 1. 构建主查询
        LambdaQueryWrapper<PendingInventory> queryWrapper = new LambdaQueryWrapper<>();
        if (pendingInventoryDto.getRegistrationDate() != null) {
            queryWrapper.eq(PendingInventory::getRegistrationDate, pendingInventoryDto.getRegistrationDate());
        }

        // 按煤种名称查询
        if (StringUtils.isNotBlank(pendingInventoryDto.getCoal())) {
            LambdaQueryWrapper<CoalInfo> coalQueryWrapper = new LambdaQueryWrapper<>();
            coalQueryWrapper.like(CoalInfo::getCoal, pendingInventoryDto.getCoal());
            List<CoalInfo> coalInfos = coalInfoMapper.selectList(coalQueryWrapper);

            if (!coalInfos.isEmpty()) {
                List<Long> coalIds = coalInfos.stream()
                        .map(CoalInfo::getId)
                        .collect(Collectors.toList());
                queryWrapper.in(PendingInventory::getCoalId, coalIds);
            } else {
                // 如果没有匹配的煤种，直接返回空结果
                queryWrapper.eq(PendingInventory::getCoalId, -1L); // 使用不可能存在的ID
            }
        }

        queryWrapper.orderByDesc(PendingInventory::getCreateTime);

        // 2. 执行主表分页查询
@@ -257,4 +298,118 @@
        }
        return i;
    }

    @Override
    @Transactional
    public boolean addPending(PendingInventoryDto pendingInventoryDto) {
        try {
            CoalPlan coalPlan = coalPlanMapper.selectOne(new LambdaQueryWrapper<CoalPlan>().eq(CoalPlan::getPlan, "配煤计算器方案"));
            if (coalPlan == null) {
                return false;
            }

            // 添加到待入库
            Long userId = SecurityUtils.getUserId();
            PendingInventory pendingInventory = new PendingInventory();
            pendingInventory.setUnit("t");
            pendingInventory.setRegistrantId(userId);
            pendingInventory.setRegistrationDate(LocalDate.now());

            for (Map<String, Object> map : pendingInventoryDto.getFieldsResultList()) {
                pendingInventory.setSupplierName("配煤计算器方案入库");

                // 处理煤炭ID
                if (map.get("coalId") == null) {
                    CoalInfo coalInfo = new CoalInfo();
                    coalInfo.setCoal((String) map.get("createCoal"));
                    coalInfo.setMaintainerId(userId);
                    coalInfo.setMaintenanceDate(LocalDate.now());
                    if (coalInfoMapper.insert(coalInfo) <= 0) {
                        return false;
                    }
                    pendingInventory.setCoalId(coalInfo.getId());
                } else {
                    pendingInventory.setCoalId((Long) map.get("coalId"));
                }

                // 设置价格和数量
                BigDecimal cost = BigDecimal.valueOf((Double) map.get("cost"));
                BigDecimal tonnage = BigDecimal.valueOf((Double) map.get("totalTonnage"));

                pendingInventory.setPriceIncludingTax(cost);
                pendingInventory.setInventoryQuantity(tonnage);
                pendingInventory.setTotalPriceIncludingTax(cost.multiply(tonnage));

                BigDecimal costExcludingTax = cost.divide(BigDecimal.valueOf(1.13), 2, RoundingMode.HALF_UP);
                pendingInventory.setPriceExcludingTax(costExcludingTax);
                pendingInventory.setTotalPriceExcludingTax(costExcludingTax.multiply(tonnage));
                pendingInventory.setCoalPlanId(coalPlan.getId());

                // 煤质字段值
                String coalFields = coalPlan.getCoalFields();
                List<String> coalFieldList = Arrays.asList(coalFields.split(","));

                for (String field : coalFieldList) {
                    CoalField coalField = coalFieldMapper.selectOne(
                            new LambdaQueryWrapper<CoalField>().eq(CoalField::getFields, field));
                    if (coalField == null) {
                        continue;
                    }

                    CoalValue coalValue = new CoalValue();
                    coalValue.setPlanId(coalPlan.getId());
                    coalValue.setFields(field);
                    coalValue.setFieldName(coalField.getFieldName());
                    coalValue.setType("1");

                    switch (coalField.getFieldName()) {
                        case "发热量":
                            coalValue.setCoalValue((String) map.get("cv"));
                            break;
                        case "硫分":
                            coalValue.setCoalValue((String) map.get("sulfur"));
                            break;
                        case "灰分":
                            coalValue.setCoalValue((String) map.get("ash"));
                            break;
                        case "水分":
                            coalValue.setCoalValue((String) map.get("moisture"));
                            break;
                    }

                    // 保存煤质值
                    if (coalValueMapper.insert(coalValue) <= 0) {
                        return false;
                    }
                }
            }

            // 插入待入库记录
            if (pendingInventoryMapper.insert(pendingInventory) <= 0) {
                return false;
            }

            // 更新正式库
            for (Map<String, Object> coalResult : pendingInventoryDto.getCoalResultList()) {
                Long officialId = (Long) coalResult.get("officialId");
                BigDecimal quantity = (BigDecimal) coalResult.get("quantity");
                OfficialInventory officialInventory = officialInventoryMapper.selectById(officialId);

                if (officialInventory == null || officialInventory.getInventoryQuantity().compareTo(quantity) < 0) {
                    throw new BaseException("库存数量不足，添加至待入库失败");
                }

                officialInventory.setInventoryQuantity(officialInventory.getInventoryQuantity().subtract(quantity));
                if (officialInventoryMapper.updateById(officialInventory) <= 0) {
                    return false;
                }
            }

            return true;
        } catch (Exception e) {
            // 记录日志
            log.error("添加待入库失败", e);
            throw new BaseException("添加待入库失败: " + e.getMessage());
        }
    }
}