基础数据配置接口修改

mitao

2024-04-12 a7a8a50f48c1bff5ddc52b3bad1782328f8043d8

 ruoyi-system/src/main/java/com/ruoyi/system/service/impl/TbBasicDataConfigServiceImpl.java

@@ -1,13 +1,17 @@
package com.ruoyi.system.service.impl;

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
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.basic.PageDTO;
import com.ruoyi.common.enums.CalculateTypeEnum;
import com.ruoyi.common.enums.ShowStatusEnum;
import com.ruoyi.common.enums.ValueTypeEnum;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.BeanUtils;
import com.ruoyi.common.utils.CalculateUtil;
import com.ruoyi.common.utils.Checker;
import com.ruoyi.common.utils.CollUtils;
import com.ruoyi.common.utils.StringUtils;
@@ -16,26 +20,29 @@
import com.ruoyi.system.domain.TbField;
import com.ruoyi.system.dto.BasicDataConfigDTO;
import com.ruoyi.system.dto.CalculateDTO;
import com.ruoyi.system.dto.CalculateItemDTO;
import com.ruoyi.system.dto.ShowHideDTO;
import com.ruoyi.system.dto.update.BasicDataConfigUpdateDTO;
import com.ruoyi.system.mapper.TbBasicDataConfigMapper;
import com.ruoyi.system.mapper.TbFieldMapper;
import com.ruoyi.system.query.BasicDataConfigQuery;
import com.ruoyi.system.query.ScoreCalculateQuery;
import com.ruoyi.system.service.TbBasicDataCategoryService;
import com.ruoyi.system.service.TbBasicDataConfigDetailService;
import com.ruoyi.system.service.TbBasicDataConfigService;
import com.ruoyi.system.vo.BasicDataConfigDetailVO;
import com.ruoyi.system.vo.BasicDataConfigVO;
import com.ruoyi.system.vo.CalculateVO;
import com.ruoyi.system.vo.ScoreCalculateVO;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import lombok.RequiredArgsConstructor;
import org.jetbrains.annotations.NotNull;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * <p>
@@ -47,23 +54,28 @@
 */
@Service
@RequiredArgsConstructor
public class TbBasicDataConfigServiceImpl extends ServiceImpl<TbBasicDataConfigMapper, TbBasicDataConfig> implements TbBasicDataConfigService {
public class TbBasicDataConfigServiceImpl extends
        ServiceImpl<TbBasicDataConfigMapper, TbBasicDataConfig> implements
        TbBasicDataConfigService {

    private final TbBasicDataConfigDetailService tbBasicDataConfigDetailService;
    private final TbFieldMapper fieldMapper;
    private final TbBasicDataCategoryService tbBasicDataCategoryService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public void add(BasicDataConfigDTO dto) {
        TbBasicDataConfig tbBasicDataConfig = BeanUtils.copyBean(dto, TbBasicDataConfig.class);
        //参数校验
        List<CalculateItemDTO> calculateItemList = dto.getCalculateItemList();
        CalculateTypeEnum calculateType = tbBasicDataConfig.getCalculateType();
        List<CalculateDTO> dtoList = dto.getDtoList();
        if (CalculateTypeEnum.NUMBER.equals(calculateType) && StringUtils.isBlank(dto.getNumberCalculateFormula())) {
            throw new ServiceException("计算公式不能为空");
        }
        boolean verify = (CalculateTypeEnum.TEXT.equals(calculateType) || CalculateTypeEnum.PERCENTAGE.equals(calculateType)) && CollUtils.isNotEmpty(dtoList);
        if (verify) {
        if (CalculateTypeEnum.NUMBER.equals(calculateType)) {
            String fieldIdStr = getFieldIdStr(calculateItemList, tbBasicDataConfig);
            tbBasicDataConfig.setFieldIdStr(fieldIdStr);
        } else {
            if (CollUtils.isEmpty(dtoList)) {
                throw new ServiceException("基础数据配置不能为空");
            } else {
            CollUtils.check(dto.getDtoList(), new Checker<CalculateDTO>() {
                @Override
                public void check(CalculateDTO data) {
@@ -75,15 +87,65 @@
                    }
                }
            });
        } else {
            throw new ServiceException("计算公式不能为空");
                if (StringUtils.isBlank(dto.getFieldIdStr())) {
                    throw new ServiceException("字段id不能为空");
        }
        this.save(tbBasicDataConfig);
        if (verify) {
            List<TbBasicDataConfigDetail> details = BeanUtils.copyList(dtoList, TbBasicDataConfigDetail.class);
            List<TbBasicDataConfigDetail> collect = details.stream().peek(item -> item.setBasicDataConfigId(tbBasicDataConfig.getId())).collect(Collectors.toList());
                List<TbBasicDataConfigDetail> details = BeanUtils.copyList(dtoList,
                        TbBasicDataConfigDetail.class);
                List<TbBasicDataConfigDetail> collect = details.stream()
                        .peek(item -> item.setBasicDataConfigId(tbBasicDataConfig.getId()))
                        .collect(Collectors.toList());
            tbBasicDataConfigDetailService.saveBatch(collect);
        }
        }
        this.save(tbBasicDataConfig);
    }

    public boolean hasConsecutiveDuplicates(List<CalculateItemDTO> calculateItemList) {
        return IntStream.range(1, calculateItemList.size())
                .anyMatch(i -> calculateItemList.get(i - 1).getValueType()
                        .equals(calculateItemList.get(i).getValueType()));
    }


    @NotNull
    private String getFieldIdStr(List<CalculateItemDTO> calculateItemList,
            TbBasicDataConfig tbBasicDataConfig) {
        if (CollUtils.isEmpty(calculateItemList)) {
            throw new ServiceException("计算公式不能为空");
        }
        CollUtils.check(calculateItemList, new Checker<CalculateItemDTO>() {
            @Override
            public void check(CalculateItemDTO data) {
                if (Objects.isNull(data.getValueType())) {
                    throw new ServiceException("基础数据配置计算规则值类型不能为空");
                }
                if (StringUtils.isBlank(data.getContent())) {
                    throw new ServiceException("基础数据配置计算规则值内容不能为空");
                }
            }
        });
        boolean result = hasConsecutiveDuplicates(calculateItemList);
        if (result) {
            throw new ServiceException("计算表达式有误，请修改");
        }
        //参数校验
        String numberCalculateFormulaStr = calculateItemList.stream()
                .map(CalculateItemDTO::getContent)
                .collect(Collectors.joining());
        //校验表达式是否正确
        try {
            CalculateUtil.calculate(numberCalculateFormulaStr);
        } catch (Exception e) {
            throw new ServiceException("计算表达式有误，请修改");
        }
        String numberCalculateFormulaJsonStr = JSON.toJSONString(calculateItemList);
        tbBasicDataConfig.setNumberCalculateFormula(numberCalculateFormulaJsonStr);
        String fieldIdStr = calculateItemList.stream()
                .filter(item -> ValueTypeEnum.FIELD.equals(item.getValueType()))
                .map(CalculateItemDTO::getContent).collect(
                        Collectors.joining(","));
        return fieldIdStr;
    }

    @Override
@@ -93,33 +155,45 @@
        //参数校验
        CalculateTypeEnum calculateType = tbBasicDataConfig.getCalculateType();
        List<CalculateDTO> dtoList = dto.getDtoList();
        if (CalculateTypeEnum.NUMBER.equals(calculateType) && StringUtils.isBlank(dto.getNumberCalculateFormula())) {
        if (CalculateTypeEnum.NUMBER.equals(calculateType)) {
            tbBasicDataConfig.setFieldIdStr(
                    getFieldIdStr(dto.getCalculateItemList(), tbBasicDataConfig));
        } else {
            if (CollUtils.isEmpty(dtoList)) {
            throw new ServiceException("计算公式不能为空");
        }
        boolean verify = CalculateTypeEnum.TEXT.equals(calculateType) || CalculateTypeEnum.PERCENTAGE.equals(calculateType);
        if (verify && CollUtils.isEmpty(dtoList)) {
            throw new ServiceException("计算公式不能为空");
        }
        this.updateById(tbBasicDataConfig);
        if (verify) {
            //删除原来的配置信息，重新添加新的
            tbBasicDataConfigDetailService.lambdaUpdate().eq(TbBasicDataConfigDetail::getBasicDataConfigId, tbBasicDataConfig.getId()).remove();
            List<TbBasicDataConfigDetail> details = BeanUtils.copyList(dtoList, TbBasicDataConfigDetail.class);
            List<TbBasicDataConfigDetail> collect = details.stream().peek(item -> item.setBasicDataConfigId(tbBasicDataConfig.getId())).collect(Collectors.toList());
            tbBasicDataConfigDetailService.lambdaUpdate()
                    .eq(TbBasicDataConfigDetail::getBasicDataConfigId, tbBasicDataConfig.getId())
                    .remove();
            List<TbBasicDataConfigDetail> details = BeanUtils.copyList(dtoList,
                    TbBasicDataConfigDetail.class);
            List<TbBasicDataConfigDetail> collect = details.stream()
                    .peek(item -> item.setBasicDataConfigId(tbBasicDataConfig.getId()))
                    .collect(Collectors.toList());
            tbBasicDataConfigDetailService.saveBatch(collect);
        }
        this.updateById(tbBasicDataConfig);
    }

    @Override
    public BasicDataConfigDetailVO getDetails(Integer id) {
    public BasicDataConfigDetailVO getDetails(Long id) {
        TbBasicDataConfig config = this.getById(id);
        if (Objects.isNull(config)) {
            throw new ServiceException("非法参数");
        }
        BasicDataConfigDetailVO vo = BeanUtils.copyBean(config, BasicDataConfigDetailVO.class);
        Integer code = vo.getCalculateType().getCode();
        if ((CalculateTypeEnum.TEXT.getCode().equals(code) || CalculateTypeEnum.PERCENTAGE.getCode().equals(code))) {
            List<TbBasicDataConfigDetail> list = tbBasicDataConfigDetailService.lambdaQuery().eq(TbBasicDataConfigDetail::getBasicDataConfigId, config.getId()).list();

        CalculateTypeEnum type = vo.getCalculateType();
        if (CalculateTypeEnum.NUMBER.equals(type)) {
            List<CalculateItemDTO> calculateItemDTOS = JSONArray.parseArray(
                    config.getNumberCalculateFormula(),
                    CalculateItemDTO.class);
            vo.setCalculateItemList(calculateItemDTOS);
        }
        if ((CalculateTypeEnum.TEXT.equals(type) || CalculateTypeEnum.PERCENTAGE.equals(type))) {
            List<TbBasicDataConfigDetail> list = tbBasicDataConfigDetailService.lambdaQuery()
                    .eq(TbBasicDataConfigDetail::getBasicDataConfigId, config.getId()).list();
            List<CalculateVO> calculateVOS = BeanUtils.copyList(list, CalculateVO.class);
            vo.setDtoList(calculateVOS);
        }
@@ -127,7 +201,7 @@
    }

    @Override
    public void delete(Integer id) {
    public void delete(Long id) {
        TbBasicDataConfig config = this.getById(id);
        if (Objects.isNull(config)) {
            throw new ServiceException("非法参数");
@@ -137,11 +211,10 @@

    @Override
    public PageDTO<BasicDataConfigVO> queryPage(BasicDataConfigQuery query) {
        Page<TbBasicDataConfig> page = this.lambdaQuery()
                .like(StringUtils.isNotBlank(query.getBasicDataConfigName()), TbBasicDataConfig::getTypeName, query.getBasicDataConfigName())
                .eq(Objects.nonNull(query.getCalculateType()), TbBasicDataConfig::getCalculateType, query.getCalculateType())
                .eq(Objects.nonNull(query.getStatus()), TbBasicDataConfig::getStatus, query.getStatus()).page(new Page<>(query.getPageNum(), query.getPageSize()));
        return PageDTO.of(page, BasicDataConfigVO.class);
        Page<Object> page = new Page<>(query.getPageNum(), query.getPageSize());
        Page<BasicDataConfigVO> pageVO = this.queryPage(
                new Page<>(query.getPageNum(), query.getPageSize()), query);
        return PageDTO.of(pageVO);
    }

    @Override
@@ -154,17 +227,29 @@
            //查询改配置所使用字段状态
            String fieldIdStr = config.getFieldIdStr();
            String[] split = fieldIdStr.split(",");
            List<TbField> list = fieldMapper.selectList(Wrappers.<TbField>lambdaQuery().in(TbField::getId, Arrays.asList(split)).eq(TbField::getStatus, ShowStatusEnum.HIDE));
            List<TbField> list = fieldMapper.selectList(
                    Wrappers.<TbField>lambdaQuery().in(TbField::getId, Arrays.asList(split))
                            .eq(TbField::getStatus, ShowStatusEnum.HIDE));
            if (CollUtils.isNotEmpty(list)) {
                String fieldNames = list.stream().map(TbField::getFieldName).collect(Collectors.joining(","));
                throw new ServiceException(String.format("字段“%s”已被隐藏，请重新配置后再次操作！", fieldNames));
                String fieldNames = list.stream().map(TbField::getFieldName)
                        .collect(Collectors.joining(","));
                throw new ServiceException(
                        String.format("字段“%s”已被隐藏，请重新配置后再次操作！", fieldNames));
            }
        }
        this.lambdaUpdate().set(TbBasicDataConfig::getStatus, dto.getStatus()).eq(TbBasicDataConfig::getId, dto.getId()).update();
        this.lambdaUpdate().set(TbBasicDataConfig::getStatus, dto.getStatus())
                .eq(TbBasicDataConfig::getId, dto.getId()).update();
    }

    @Override
    public Page<ScoreCalculateVO> scoreCalculatePage(ScoreCalculateQuery query, Page<ScoreCalculateVO> page) {
    public Page<ScoreCalculateVO> scoreCalculatePage(ScoreCalculateQuery query,
            Page<ScoreCalculateVO> page) {
        return baseMapper.scoreCalculatePage(query, page);
    }

    @Override
    public Page<BasicDataConfigVO> queryPage(Page<BasicDataConfigVO> page,
            BasicDataConfigQuery query) {
        return baseMapper.queryPage(page, query);
    }
}