smartrobot-java/ruoyi-system/src/main/java/com/ruoyi/business/service/impl/BusinessServiceImpl.java

package com.ruoyi.business.service.impl;

import com.ruoyi.business.domain.BizDevice;
import com.ruoyi.business.domain.ZAssay;
import com.ruoyi.business.domain.ZAssayResult;
import com.ruoyi.business.domain.ZQualityValue;
import com.ruoyi.business.mapper.*;
import com.ruoyi.business.res.HomeCountsRes;
import com.ruoyi.business.service.IBusinessService;
import com.ruoyi.common.enums.DataSourceType;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

@Service
public class BusinessServiceImpl implements IBusinessService {


    @Autowired
    private BizDeviceMapper bizDeviceMapper;

    @Autowired
    private BizWaterWorkMapper bizWaterWorkMapper;

    @Autowired
    private ZAssayMapper zAssayMapper;

    @Autowired
    private ZAssayResultMapper zAssayResultMapper;

    @Autowired
    private ZQualityValueMapper zQualityValueMapper;


    @Override
    public HomeCountsRes homeCountsInfo(int type) {//type 1:化验室，2：连续检测
        HomeCountsRes build = HomeCountsRes.builder().build();
        //处理各个维度的统计信息
        //获取所有的正在使用的设备列表 大概几十个，所以直接取所有数据，下面再过滤
        List<BizDevice> bizDevices = this.bizDeviceMapper.selectBizDeviceList(BizDevice.builder().deviceStatus("0").build());
        //一定有设备 并且mybatis返回的默认是空集合new出来的而不是null，所以这里不用判断
        List<BizDevice> totalList = bizDevices.stream().filter(bizDevice -> String.valueOf(type).equals(bizDevice.getType())).collect(Collectors.toList());
        if (!CollectionUtils.isEmpty(totalList)) {
            build.setDeviceTotals((long) totalList.size());
            //化验中
            build.setOnDeviceCounts(totalList.stream().filter(bizDevice -> "2".equals(bizDevice.getAssayStatus())).count());
            //待机
            build.setStandbyDeviceCounts(totalList.stream().filter(bizDevice -> "0".equals(bizDevice.getAssayStatus())).count());
            //离线
            build.setOffDeviceCounts(totalList.stream().filter(bizDevice -> "1".equals(bizDevice.getAssayStatus())).count());
        }
        //统计今日的化验数据
        //先获取今日的所有的化验的质控样数据 再编写通用方法，判断是否合格，再获取合格的数量
        //todo 日期临时写死，因为数据不会同步，都是历史数据  正式以后，需要改成真实日期
//        List<ZAssayResult> zAssayResults = this.zAssayResultMapper.selectZAssayResultList(ZAssayResult.builder().resultDate(DateUtils.getDate()).assayType("3").build());
        List<ZAssayResult> zAssayResults = this.zAssayResultMapper.selectZAssayResultList(ZAssayResult.builder().resultDate("2024-08-13").assayType("3").build());
        if(!CollectionUtils.isEmpty(zAssayResults)){
            int checkTotals = zAssayResults.size();
            build.setCheckTotals(checkTotals);
            int passCheckTotals = this.getPassedCounts(zAssayResults);
            build.setPassCheckTotals(passCheckTotals);
            build.setPassCheckRates((double)passCheckTotals / (double)checkTotals);//整数除以整数还是整数，所以这里要强转成小数
        }
        return build;
    }

    //判断每个质控样的数是否各个，然后获取汇总的数量
    private int getPassedCounts(List<ZAssayResult> zAssayResults) {
        boolean passed = false;
        int count = 0;
        for (ZAssayResult zAssayResult : zAssayResults) {
            passed = this.isPassed(zAssayResult);
            if (passed) {
                count++;//通过 数量加一
            }
        }
        return count;
    }

    //获取每个质控样的数据是否是合格的
    private boolean isPassed(ZAssayResult zAssayResult) {
        boolean isPassed = true;//默认是合格的，防止一些极端场景：没有配置范围  范围配置时间过期等等情况
        String deviceNo = zAssayResult.getDeviceNo();
        if(StringUtils.isBlank(deviceNo))
            return isPassed;//无法关联数据，默认合格
        //需要通过化验明细里的设备ID找到水厂ID，配置的表需要该参数
        List<BizDevice> bizDevices = this.bizDeviceMapper.selectBizDeviceList(BizDevice.builder().deviceNo(deviceNo).build());
        if(CollectionUtils.isEmpty(bizDevices)){
            return isPassed;//无法查询到水厂，默认合格
        }
        //todo 日期临时写死，因为数据不会同步，都是历史数据  正式以后，需要改成真实日期
//        Date nowDate = DateUtils.getNowDate();
        Date nowDate = DateUtils.parseDate("2024-08-13");
        Long resultConcentration = zAssayResult.getResultConcentration();//化验的真实值
        //去查询配置的标准值的范围（数据不确认，有可能是多个，获取最后一条数据）：
        List<ZQualityValue> list = this.zQualityValueMapper.selectZQualityValueList(ZQualityValue.builder().beginTime(nowDate).endTime(nowDate).deviceWorks(bizDevices.get(0).getDeviceWorks()).assayItem(zAssayResult.getAssayItem()).build());
        //理论上是只有一个的
        if(!CollectionUtils.isEmpty(list)){
            ZQualityValue zQualityValue = list.get(list.size() - 1);//获取最新的一条，防止有多条数据的情况
            Long lowValue = zQualityValue.getLowValue();
            Long highValue = zQualityValue.getHighValue();
            if(!Objects.isNull(resultConcentration) && !Objects.isNull(lowValue) && !Objects.isNull(highValue)){
                isPassed = resultConcentration >= lowValue && resultConcentration <= highValue;
            }
        }
        return isPassed;
    }


    public static void main(String[] args) {
        List list = new ArrayList<>();
        list.add(1);
        list.add(1);
        System.out.println(list.stream().count());

        System.out.println(DateUtils.getDate());
    }
}