!57 能源流向分析 Merge pull request !57 from DYL0109/dyl_dev

DYL0109

2025-02-11 0e49c2c61b26146d1a826edd6afa5d8c03696e59

!57 能源流向分析
Merge pull request !57 from DYL0109/dyl_dev

 zhitan-admin/src/main/java/com/zhitan/web/controller/common/CommonController.java

@@ -1,10 +1,12 @@
package com.zhitan.web.controller.common;

import java.util.ArrayList;
import java.util.List;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.zhitan.common.config.BaseConfig;
import com.zhitan.common.constant.Constants;
import com.zhitan.common.core.domain.AjaxResult;
import com.zhitan.common.utils.StringUtils;
import com.zhitan.common.utils.file.FileUploadUtils;
import com.zhitan.common.utils.file.FileUtils;
import com.zhitan.framework.config.ServerConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.http.MediaType;
@@ -13,13 +15,12 @@
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;
import com.zhitan.common.config.BaseConfig;
import com.zhitan.common.constant.Constants;
import com.zhitan.common.core.domain.AjaxResult;
import com.zhitan.common.utils.StringUtils;
import com.zhitan.common.utils.file.FileUploadUtils;
import com.zhitan.common.utils.file.FileUtils;
import com.zhitan.framework.config.ServerConfig;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.ArrayList;
import java.util.List;

/**
 * é€šç”¨è¯·æ±‚处理
@@ -36,6 +37,9 @@
    private ServerConfig serverConfig;

    private static final String FILE_DELIMETER = ",";

    @Resource
    private BaseConfig baseConfig;

    /**
     * é€šç”¨ä¸‹è½½è¯·æ±‚
@@ -81,7 +85,7 @@
            String filePath = BaseConfig.getUploadPath();
            // ä¸Šä¼ å¹¶è¿”回新文件名称
            String fileName = FileUploadUtils.upload(filePath, file);
            String url = serverConfig.getUrl() + fileName;
            String url = baseConfig.getDomainName() + fileName;
            AjaxResult ajax = AjaxResult.success();
            ajax.put("url", url);
            ajax.put("fileName", fileName);

 zhitan-admin/src/main/java/com/zhitan/web/controller/energyMonitor/ElectricLoadController.java

@@ -1,9 +1,12 @@
package com.zhitan.web.controller.energyMonitor;

import com.zhitan.common.annotation.Log;
import com.zhitan.common.constant.CommonConst;
import com.zhitan.common.core.controller.BaseController;
import com.zhitan.common.core.domain.AjaxResult;
import com.zhitan.energyMonitor.service.IEnergyUnitToDeviceService;
import com.zhitan.energyMonitor.domain.vo.ListElectricLoadVO;
import com.zhitan.energyMonitor.service.IElectricLoadService;
import com.zhitan.model.domain.EnergyIndex;
import com.zhitan.model.service.IEnergyIndexService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
@@ -26,33 +29,29 @@
@Slf4j
public class ElectricLoadController extends BaseController {
    @Autowired
    private IEnergyUnitToDeviceService energyUnitToDeviceService;
//    @Autowired
//    private IElectricLoadService electricLoadService;
    private IElectricLoadService electricLoadService;
    @Autowired
    private IEnergyIndexService energyIndexService;

    /**
     * æ ¹æ®ç”µè¡¨id获取负荷分析数据
     *
     * @param energyUnitId ç”¨èƒ½å•å…ƒid
     * @param meterId      ç”µè¡¨id
     * @param timeType     æ—¶é—´ç±»åž‹ DAY/MONTH/YEAR
     * @param timeCode     æ—¶é—´å€¼ ä¸Žæ—¶é—´ç±»åž‹å¯¹åº”：2022-03-21/2022-03/2022
     * @return
     * @param nodeId   ç”¨èƒ½å•å…ƒid
     * @param meterId  ç”µè¡¨id
     * @param timeType æ—¶é—´ç±»åž‹ DAY/MONTH/YEAR
     * @param timeCode æ—¶é—´å€¼ ä¸Žæ—¶é—´ç±»åž‹å¯¹åº”：2022-03-21/2022-03/2022
     */
    @Log(title = "根据电表id获取负荷分析数据")
    @ApiOperation(value = "根据电表id获取负荷分析数据", notes = "根据电表id获取负荷分析数据")
    @GetMapping(value = "/detail")
    public AjaxResult list(@RequestParam(name = "energyUnitId") String energyUnitId,
    public AjaxResult list(@RequestParam(name = "nodeId") String nodeId,
                           @RequestParam(name = "meterId") String meterId,
                           @RequestParam(name = "timeType") String timeType,
                           @RequestParam(name = "timeCode") String timeCode) {
//        EnergyIndex energyIndex = energyIndexService.getDeviceIndexByCode(energyUnitId, meterId, CommonConst.TAG_CODE_ZYGGL);
//
//        EnergyUnitToDevice energyUnitToDevice = energyUnitToDeviceService.getEnergyUnitToDeviceById(energyUnitId, meterId);
//        ListElectricLoadVO lsvo = electricLoadService.list(timeType, timeCode, energyIndex, energyUnitToDevice);
        return AjaxResult.success(null);
        EnergyIndex energyIndex = energyIndexService.getDeviceIndexByCode(nodeId, meterId, CommonConst.TAG_CODE_ZYGGL);

        ListElectricLoadVO vo = electricLoadService.list(timeType, timeCode, energyIndex);
        return AjaxResult.success(vo);
    }

}

 zhitan-admin/src/main/java/com/zhitan/web/controller/energyMonitor/ElectricPowerFactorController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,55 @@
package com.zhitan.web.controller.energyMonitor;

import com.zhitan.common.annotation.Log;
import com.zhitan.common.constant.CommonConst;
import com.zhitan.common.core.controller.BaseController;
import com.zhitan.common.core.domain.AjaxResult;
import com.zhitan.energyMonitor.service.IElectricPowerFactorService;
import com.zhitan.model.domain.EnergyIndex;
import com.zhitan.model.service.IEnergyIndexService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @Description: åŠŸçŽ‡å› æ•°
 * @Author: yxw
 * @Date: 2022-04-24
 * @Version: V1.2
 */
@Api(tags = "功率因数")
@RestController
@RequestMapping("/powerFactorAnalysis")
@Slf4j
public class ElectricPowerFactorController extends BaseController {

    @Autowired
    private IElectricPowerFactorService electricPowerFactorService;

    @Autowired
    private IEnergyIndexService energyIndexService;

    /**
     * æ ¹æ®ç”µè¡¨id获取功率因数数据
     *
     * @param nodeId   èŠ‚点id
     * @param meterId  ç”µè¡¨id
     * @param timeCode æ—¶é—´å€¼ ä¸Žæ—¶é—´ç±»åž‹å¯¹åº”：2022-03-21
     */
    @Log(title = "根据电表id获取功率因数数据")
    @ApiOperation(value = "根据电表id获取功率因数数据", notes = "根据电表id获取功率因数数据")
    @GetMapping(value = "/detail")
    public AjaxResult list(@RequestParam(name = "nodeId") String nodeId,
                           @RequestParam(name = "meterId") String meterId,
                           @RequestParam(name = "timeCode") String timeCode) {
        EnergyIndex energyIndex = energyIndexService.getDeviceIndexByCode(nodeId, meterId, CommonConst.TAG_CODE_GLYS);

        return AjaxResult.success(electricPowerFactorService.list(timeCode, energyIndex));
    }

}

 zhitan-admin/src/main/java/com/zhitan/web/controller/energyMonitor/ElectricThreePhaseController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,64 @@
package com.zhitan.web.controller.energyMonitor;

import com.zhitan.common.annotation.Log;
import com.zhitan.common.core.controller.BaseController;
import com.zhitan.common.core.domain.AjaxResult;
import com.zhitan.energyMonitor.service.IElectricThreePhaseService;
import com.zhitan.model.domain.EnergyIndex;
import com.zhitan.model.service.IEnergyIndexService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @Description: ä¸‰ç›¸ä¸å¹³è¡¡
 * @Author: yxw
 * @Date: 2022-04-24
 * @Version: V1.2
 */
@Api(tags = "三相不平衡")
@RestController
@RequestMapping("/threePhaseUnbalanceAnalysis")
@Slf4j
public class ElectricThreePhaseController extends BaseController {

    @Autowired
    private IElectricThreePhaseService electricThreePhaseService;
    @Autowired
    private IEnergyIndexService energyIndexService;

    /**
     * èŽ·å–用能单元下的某个电表的三相不平衡数据
     *
     * @param nodeId èŠ‚点id
     * @param meterId      ç”µè¡¨id
     * @param timeType     æ—¶é—´ç±»åž‹ DAY/MONTH/YEAR
     * @param timeCode     æ—¶é—´å€¼ ä¸Žæ—¶é—´ç±»åž‹å¯¹åº”：2022-03-21/2022-03/2022
     * @param requestType  è¯·æ±‚类型：0.电压；1.电流
     * @return
     */
    @Log(title = "根据电表id查询三相不平衡数据")
    @ApiOperation(value = "根据电表id查询三相不平衡数据", notes = "根据电表id查询三相不平衡数据")
    @GetMapping(value = "/detail")
    public AjaxResult list(@RequestParam(name = "nodeId") String nodeId,
                           @RequestParam(name = "meterId") String meterId,
                           @RequestParam(name = "timeType") String timeType,
                           @RequestParam(name = "timeCode") String timeCode,
                           @RequestParam(name = "requestType") String requestType) {
        if (ObjectUtils.isEmpty(meterId)){
            return AjaxResult.error("电表id不能为空");
        }
        List<EnergyIndex> energyIndexList = energyIndexService.listDeviceIndex(nodeId, meterId);

        return AjaxResult.success(electricThreePhaseService.list(timeType, timeCode, energyIndexList, requestType, meterId));
    }

}

 zhitan-admin/src/main/java/com/zhitan/web/controller/statisticalAnalysis/EnergyDataItemController.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,39 @@
package com.zhitan.web.controller.statisticalAnalysis;

import com.zhitan.common.annotation.Log;
import com.zhitan.common.core.domain.AjaxResult;
import com.zhitan.dataitem.service.IDataItemService;
import com.zhitan.statisticalAnalysis.domain.dto.FlowChartsDTO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


/**
 * èƒ½è€—统计分析
 */
@Api(tags = "能耗统计分析")
@RestController
@RequestMapping("/statisticsAnalysis")
public class EnergyDataItemController {

    @Autowired
    private IDataItemService dataItemService;

    /**
     * èŽ·å–能流图形分析
     *
     * @param dto è¯·æ±‚参数
     * @return ç»“æžœ
     */
    @Log(title = "获取能流图形分析")
    @ApiOperation(value = "获取能流图形分析", notes = "获取能流图形分析")
    @GetMapping(value = "/getFlowCharts")
    public AjaxResult getFlowCharts(@Validated FlowChartsDTO dto) {
        return AjaxResult.success(dataItemService.getFlowCharts(dto));
    }
}

 zhitan-admin/src/main/resources/application.yml

@@ -11,6 +11,8 @@
  addressEnabled: true
  # éªŒè¯ç ç±»åž‹ math æ•°å­—计算 char å­—符验证
  captchaType: math
  # åŸŸååœ°å€
  domainName: https://demo-ems.zhitancloud.com/prod-api

# å¼€å‘环境配置
server:

 zhitan-common/src/main/java/com/zhitan/common/config/BaseConfig.java

@@ -30,6 +30,12 @@
    /** éªŒè¯ç ç±»åž‹ */
    private static String captchaType;

    /**
     * æ–‡ä»¶åœ°å€åŸŸå
     */
    private String domainName;


    public String getName()
    {
        return name;
@@ -123,4 +129,12 @@
    public static String getConfigurePath() {
        return getProfile() + "/configure";
    }

    public String getDomainName() {
        return domainName;
    }

    public void setDomainName(String domainName) {
        this.domainName = domainName;
    }
}

 zhitan-common/src/main/java/com/zhitan/common/utils/ChartUtils.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,177 @@
package com.zhitan.common.utils;


import com.zhitan.common.constant.CommonConst;
import com.zhitan.common.constant.TimeTypeConst;

import java.util.Date;
import java.util.List;

/**
 * @Description: ç»Ÿè®¡å›¾ç›¸å…³æ•°æ®å·¥å…·ç±»
 * @author: yxw
 * @date: 2022å¹´04月28日 15:29
 */
public class ChartUtils {

    /**
     * æž„造日期列表
     *
     * @param timeType
     * @param timeCode
     * @param dateList
     */
    public static void generateDateList(String timeType, String timeCode, List<Date> dateList) {
        Date now = new Date();
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_DAY:
                if (!timeCode.contains(CommonConst.SINGLE_MINUS_SIGN)) {
                    timeCode = DateTimeUtil.toDateTimeStr(timeCode, DateTimeUtil.COMMON_PATTERN_DAY, DateTimeUtil.COMMON_PATTERN_TO_DAY);
                }
                int hour = 23;
                for (int i =  CommonConst.DIGIT_0; i <= hour; i++) {
                    String tempCode = timeCode + " 0" + i;
                    if (i > 9) {
                        tempCode = timeCode + " " + i;
                    }
                    Date tempD = DateTimeUtil.toDateTime(tempCode, DateTimeUtil.COMMON_PATTERN_TO_HOUR);
                    dateList.add(tempD);
                }
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                if (!timeCode.contains(CommonConst.SINGLE_MINUS_SIGN)) {
                    timeCode = DateTimeUtil.toDateTimeStr(timeCode, DateTimeUtil.COMMON_PATTERN_MONTH, DateTimeUtil.COMMON_PATTERN_TO_MONTH);
                }
                int max = DateTimeUtil.getDateTimeLastDay(DateTimeUtil.toDateTime(timeCode, DateTimeUtil.COMMON_PATTERN_TO_MONTH));

                for (int i =  CommonConst.DIGIT_1; i <= max; i++) {
                    String tempCode = timeCode + "-0" + i;
                    if (i > 9) {
                        tempCode = timeCode + "-" + i;
                    }
                    Date tempD = DateTimeUtil.toDateTime(tempCode, DateTimeUtil.COMMON_PATTERN_TO_DAY);
                    dateList.add(tempD);
                }
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                int monthMax = 12;
                for (int i = CommonConst.DIGIT_1; i <= monthMax; i++) {
                    String tempCode = timeCode + "-0" + i;
                    if (i > 9) {
                        tempCode = timeCode + "-" + i;
                    }
                    Date tempD = DateTimeUtil.toDateTime(tempCode, DateTimeUtil.COMMON_PATTERN_TO_MONTH);
                    dateList.add(tempD);
                }
                break;
            default:
                break;
        }
    }

    /**
     * èŽ·å–对应的结束时间
     *
     * @param timeType
     * @param date
     * @return
     */
    public static Date getEndTime(String timeType, Date date) {
        Date d1 = new Date();
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_DAY:
                d1 = DateTimeUtil.addDays(date, CommonConst.DIGIT_1);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                d1 = DateTimeUtil.addMonths(date, CommonConst.DIGIT_1);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                d1 = DateTimeUtil.addYears(date, CommonConst.DIGIT_1);
                break;
            default:
                break;
        }
        return d1;
    }

    /**
     * èŽ·å–日期显示字符
     *
     * @param timeType
     * @param date
     * @return
     */
    public static String getTimeCode(String timeType, Date date) {
        String str = CommonConst.EMPTY;
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_DAY:
                str = DateTimeUtil.getDateTime(date, DateTimeUtil.COMMON_PATTERN_TO_HOUR);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                str = DateTimeUtil.getDateTime(date, DateTimeUtil.COMMON_PATTERN_TO_DAY);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                str = DateTimeUtil.getDateTime(date, DateTimeUtil.COMMON_PATTERN_TO_MONTH);
                break;
            default:
                break;
        }
        return str;
    }

    /**
     * èŽ·å–日期显示字符
     *
     * @param timeType
     * @param date
     * @return
     */
    public static String getTimeCodeChart(String timeType, Date date) {
        String str = CommonConst.EMPTY;
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_DAY:
                str = DateTimeUtil.getDateTime(date, DateTimeUtil.COMMON_PATTERN_HOUR_MINUTE);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                str = DateTimeUtil.getDateTime(date, DateTimeUtil.COMMON_PATTERN_MONTH_DAY);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                str = DateTimeUtil.getDateTime(date, DateTimeUtil.COMMON_PATTERN_TO_MONTH);
                break;
            default:
                break;
        }
        return str;
    }

    /**
     * èŽ·å–日期显示字符
     *
     * @param timeType
     * @param timeCode
     * @return
     */
    public static Date getDateTime(String timeType, String timeCode) {
        Date d1 = new Date();
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_DAY:
                if (!timeCode.contains(CommonConst.SINGLE_MINUS_SIGN)) {
                    timeCode = DateTimeUtil.toDateTimeStr(timeCode, DateTimeUtil.COMMON_PATTERN_DAY, DateTimeUtil.COMMON_PATTERN_TO_DAY);
                }
                d1 = DateTimeUtil.toDateTime(timeCode, DateTimeUtil.COMMON_PATTERN_TO_DAY);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                if (!timeCode.contains(CommonConst.SINGLE_MINUS_SIGN)) {
                    timeCode = DateTimeUtil.toDateTimeStr(timeCode, DateTimeUtil.COMMON_PATTERN_MONTH, DateTimeUtil.COMMON_PATTERN_TO_MONTH);
                }
                d1 = DateTimeUtil.toDateTime(timeCode, DateTimeUtil.COMMON_PATTERN_TO_MONTH);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                d1 = DateTimeUtil.toDateTime(timeCode, DateTimeUtil.COMMON_PATTERN_YEAR);
                break;
            default:
                break;
        }
        return d1;
    }
}

 zhitan-common/src/main/java/com/zhitan/common/utils/DateTimeUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,748 @@
package com.zhitan.common.utils;

import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import com.zhitan.common.constant.CommonConst;
import com.zhitan.common.constant.TimeTypeConst;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.time.DateUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * @Description: æ—¶é—´å·¥å…·ç±»
 * @author: yxw
 * @date: 2022å¹´02月02日 12:23
 */
@Slf4j
public class DateTimeUtil {
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼
     */
    public static final String COMMON_PATTERN = "yyyy-MM-dd HH:mm:ss";
    /**
     * æ ¼å¼åŒ–日期到分钟
     */
    public static final String COMMON_PATTERN_END_WITH_MINUTE = "yyyy-MM-dd HH:mm";
    /**
     * æ—¥æœŸæ ¼å¼ - å°æ—¶:分钟
     */
    public static final String COMMON_PATTERN_HOUR_MINUTE = "HH:mm";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - å¹´ä»½
     */
    public static final String COMMON_PATTERN_YEAR = "yyyy";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - æŸä¸€å¹´,
     */
    public static final String COMMON_PATTERN_CERTAIN_YEAR = "yy";

    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - æœˆä»½
     */
    public static final String COMMON_PATTERN_MONTH = "yyyyMM";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - æœˆä»½
     */
    public static final String COMMON_PATTERN_TO_MONTH = "yyyy-MM";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - æœˆä»½
     */
    public static final String COMMON_PATTERN_TO_MONTH_WORD = "yyyy-MM月";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - æœˆä»½
     */
    public static final String COMMON_PATTERN_TO_MONTH_ZH = "yyyyå¹´MM月";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - å¤©
     */
    public static final String COMMON_PATTERN_DAY = "yyyyMMdd";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - å¤©
     */
    public static final String COMMON_PATTERN_TO_DAY = "yyyy-MM-dd";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - å¤©
     */
    public static final String COMMON_PATTERN_TO_DAY_WORD = "yyyy-MM-dd日";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - æœˆæ—¥
     */
    public static final String COMMON_PATTERN_MONTH_DAY = "MM-dd";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - å¤©æŸä¸€å¤©,
     */
    public static final String COMMON_PATTERN_DAY_OF_MONTH = "dd";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - å°æ—¶
     */
    public static final String COMMON_PATTERN_HOUR = "yyyyMMddHH";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - å°æ—¶
     */
    public static final String COMMON_PATTERN_TO_HOUR = "yyyy-MM-dd HH";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - å°æ—¶
     */
    public static final String COMMON_PATTERN_TO_HOUR_WORD = "yyyy-MM-dd HH时";
    /**
     * æ—¥æœŸå¸¸ç”¨æ ¼å¼ - å°æ—¶
     */
    public static final String COMMON_PATTERN_TO_HOUR_TEXT = "yyyyå¹´MM月dd日 HH时";

    /**
     * èŽ·å–当前时间,时间格式：yyyy-MM-dd HH:mm:ss
     *
     * @return
     */
    public static String getNowDateTime() {
        return getNowDateTime(COMMON_PATTERN);
    }

    /**
     * èŽ·å–当前时间
     *
     * @param pattern æ—¶é—´æ ¼å¼
     * @return
     */
    public static String getNowDateTime(String pattern) {
        //设置日期格式
        SimpleDateFormat df = new SimpleDateFormat(pattern);
        String dateTime = df.format(new Date());
        return dateTime;
    }

    /**
     * èŽ·å–今年的年份值
     *
     * @return
     */
    public static String getNowYear() {
        return getNowDateTime(COMMON_PATTERN_YEAR);
    }

    /**
     * èŽ·å–今年的月份值
     *
     * @return
     */
    public static String getNowMonth() {
        return getNowDateTime(COMMON_PATTERN_MONTH);
    }

    /**
     * å­—符串转成时间类型,默认格式：yyyy-MM-dd HH:mm:ss
     *
     * @param dateTimeStr
     * @return
     */
    public static Date toDateTime(String dateTimeStr) {
        DateTime dt = null;
        try {
            dt = DateTime.of(dateTimeStr, COMMON_PATTERN);
        } catch (Exception e) {

        }
        return dt;
    }

    /**
     * å­—符串转成时间类型
     *
     * @param dateTimeStr
     * @return
     */
    public static Date toDateTime(String dateTimeStr, String pattern) {
        DateTime dt = null;
        try {
            dt = DateTime.of(dateTimeStr, pattern);
        } catch (Exception e) {

        }
        return dt;
    }

    /**
     * å­—符串转成特定格式的时间字符串类型
     *
     * @param dateTimeStr   æ—¶é—´å­—符串
     * @param sourcePattern å­—符串时间格式
     * @param toPattern     è¦è½¬æˆä»€ä¹ˆæ ¼å¼çš„时间
     * @return
     */
    public static String toDateTimeStr(String dateTimeStr, String sourcePattern, String toPattern) {
        String str = CommonConst.EMPTY;
        try {
            DateTime dt = DateTime.of(dateTimeStr, sourcePattern);
            str = getDateTime(dt, toPattern);
        } catch (Exception e) {

        }
        return str;
    }

    /**
     * æ—¶é—´è½¬æˆæŒ‡å®šçš„格式
     *
     * @param pattern æ—¶é—´æ ¼å¼
     * @return
     */
    public static String getDateTime(Date dt, String pattern) {
        //设置日期格式
        SimpleDateFormat df = new SimpleDateFormat(pattern);
        return df.format(dt);
    }

    /**
     * æ—¶é—´è½¬æˆyyyy-MM-dd HH:mm:ss格式
     *
     * @return
     */
    public static String getDateTime(Date dt) {
        if (ObjectUtil.isEmpty(dt)) {
            return CommonConst.EMPTY;
        }
        return getDateTime(dt, COMMON_PATTERN);
    }

    /**
     * èŽ·å–当前时间所属月份的最后一天
     *
     * @return
     */
    public static int getDateTimeLastDay(Date dt) {
        String month = getMonth(dt);
        String firstDate = month + "01";
        Date nextMonthFirstDate = addMonths(toDateTime(firstDate, COMMON_PATTERN_DAY), CommonConst.DIGIT_1);
        Date currentMonthLastDate = addDays(nextMonthFirstDate, CommonConst.DIGIT_MINUS_1);
        int day = IntegerUtil.toInt(getDateTime(currentMonthLastDate, COMMON_PATTERN_DAY_OF_MONTH));
        return day;
    }

    /**
     * èŽ·å–年份值
     *
     * @return
     */
    public static String getYear(Date dt) {
        return getDateTime(dt, COMMON_PATTERN_YEAR);
    }

    /**
     * èŽ·å–月份值 202202
     *
     * @return
     */
    public static String getMonth(Date dt) {
        return getDateTime(dt, COMMON_PATTERN_MONTH);
    }

    /**
     * èŽ·å–天,格式：yyyyMMdd
     *
     * @return
     */
    public static String toDay(Date dt) {
        return getDateTime(dt, COMMON_PATTERN_DAY);
    }

    /**
     * èŽ·å–小时:yyyyMMddHH
     *
     * @return
     */
    public static String toHour(Date dt) {
        return getDateTime(dt, COMMON_PATTERN_HOUR);
    }

    /**
     * è½¬æˆå­—符串类型值
     *
     * @return
     */
    public static String toString(Date dt) {
        return getDateTime(dt, COMMON_PATTERN);
    }

    /**
     * æ—¶é—´å¢žåŠ å¯¹åº”çš„å¹´æ•°
     *
     * @param dateTime
     * @param years
     * @return
     */
    public static Date addYears(Date dateTime, int years) {
        return calcDate(dateTime, years, Calendar.YEAR);
    }

    /**
     * æ—¶é—´å¢žåŠ å¯¹åº”的月数
     *
     * @param dateTime
     * @param months
     * @return
     */
    public static Date addMonths(Date dateTime, int months) {
        return calcDate(dateTime, months, Calendar.MONTH);
    }

    /**
     * æ—¶é—´å¢žåŠ å¯¹åº”的天数
     *
     * @param dateTime
     * @param days
     * @return
     */
    public static Date addDays(Date dateTime, int days) {
        return calcDate(dateTime, days, Calendar.DATE);
    }

    /**
     * æ—¶é—´å¢žåŠ å¯¹åº”的小时数
     *
     * @param dateTime
     * @param hours
     * @return
     */
    public static Date addHours(Date dateTime, int hours) {
        return calcDate(dateTime, hours, Calendar.HOUR);
    }

    /**
     * æ—¶é—´å¢žåŠ å¯¹åº”的分钟数
     *
     * @param dateTime
     * @param minutes
     * @return
     */
    public static Date addMinutes(Date dateTime, int minutes) {
        return calcDate(dateTime, minutes, Calendar.MINUTE);
    }

    /**
     * æ—¶é—´å¢žåŠ å¯¹åº”的小时数
     *
     * @param dateTime
     * @param seconds
     * @return
     */
    public static Date addSeconds(Date dateTime, int seconds) {
        return calcDate(dateTime, seconds, Calendar.SECOND);
    }

    /**
     * è®¡ç®—日期通用方法
     *
     * @param dateTime
     * @param addValue
     * @param calendarType è®¡ç®—类型：Calendar.YEAR，Calendar.MONTH,Calendar.DAY
     * @return
     */
    private static Date calcDate(Date dateTime, int addValue, int calendarType) {
        Date dt = null;
        try {
            Calendar calendar = new GregorianCalendar();
            calendar.setTime(dateTime);
            //把日期往后增加一年，整数往后推，负数往前移
            calendar.add(calendarType, addValue);
            // èŽ·å–相加或者相减之后的时间值
            Date tempDt = calendar.getTime();
            // æŠŠæ—¶é—´è½¬æˆæ‰€éœ€è¦çš„格式
            String temp = getDateTime(tempDt, COMMON_PATTERN);
            dt = toDateTime(temp);
        } catch (Exception e) {

        }
        return dt;
    }

    /**
     * èŽ·å–该时间属于当天的第几个小时
     *
     * @param dateTime
     * @return
     */
    public static int getHourOfDay(Date dateTime) {
        return getDateValue(dateTime, Calendar.HOUR_OF_DAY);
    }

    /**
     * èŽ·å–该时间属于当月的第几天
     *
     * @param dateTime
     * @return
     */
    public static int getDayOfMonth(Date dateTime) {
        return getDateValue(dateTime, Calendar.DAY_OF_MONTH);
    }

    /**
     * èŽ·å–该时间属于当周的第几天
     * ä¸€å‘¨çš„第一天是周日
     *
     * @param dateTime
     * @return
     */
    public static int getDayOfWeek(Date dateTime) {
        return getDateValue(dateTime, Calendar.DAY_OF_WEEK);
    }

    /**
     * èŽ·å–该时间属于年的第几个月
     * æœˆä»½å€¼+1是真实的当前月
     *
     * @param dateTime
     * @return å·²ç»åœ¨ç³»ç»Ÿä¸­èŽ·å–值的基础上加1了，现在是真实的当前月份值
     */
    public static int getMonthOfYear(Date dateTime) {
        return getDateValue(dateTime, Calendar.MONTH) + 1;
    }

    /**
     * èŽ·å–当天的第几个小时/当月的第几天/当年的第几个月
     *
     * @param dateTime     å¦‚果时间值为空，默认当前时间
     * @param calendarType
     * @return
     */
    private static int getDateValue(Date dateTime, int calendarType) {
        int value = 0;
        try {
            if (ObjectUtil.isEmpty(dateTime)) {
                dateTime = new Date();
            }
            Calendar calendar = new GregorianCalendar();
            calendar.setTime(dateTime);
            value = calendar.get(calendarType);
        } catch (Exception e) {

        }
        return value;
    }

    /**
     * å¯¹æ¯”time1 å’Œ time2 çš„大小
     *
     * @param time1
     * @param time2
     * @return -1:time1小于time2;0:time1等于time2;1:time1大于time2;
     */
    public static int compareDateDiff(Date time1, Date time2) {
        long diff = time1.getTime() - time2.getTime();
        int res = 0;
        if (diff > 0) {
            res = 1;
        } else if (diff < 0) {
            res = -1;
        }
        return res;
    }

    /**
     * èŽ·å–查询data_item所需要的timecode值
     *
     * @param timeType æ—¥æœŸç±»åž‹
     * @param date     æ—¶é—´
     * @return
     */
    public static String getTimeCode(String timeType, Date date) {
        String timeCode = CommonConst.EMPTY;
        if (ObjectUtil.isEmpty(date)) {
            date = new Date();
        }
        timeType = StringUtil.ifEmptyOrNullReturnValue(timeType).toUpperCase();
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_HOUR:
                timeCode = CommonConst.WORD_H + getDateTime(date, COMMON_PATTERN_HOUR);
                break;
            case TimeTypeConst.TIME_TYPE_DAY:
                timeCode = CommonConst.WORD_D + getDateTime(date, COMMON_PATTERN_DAY);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                timeCode = CommonConst.WORD_M + getDateTime(date, COMMON_PATTERN_MONTH);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                timeCode = CommonConst.WORD_Y + getDateTime(date, COMMON_PATTERN_YEAR);
                break;
            default:
                break;
        }
        return timeCode;
    }

    /**
     * èŽ·å–查询日月年报表所需要的timecode值
     *
     * @param timeType æ—¥æœŸç±»åž‹
     * @param date     æ—¶é—´
     * @return
     */
    public static String getReportTimeCode(String timeType, Date date) {
        String timeCode = CommonConst.EMPTY;
        if (ObjectUtil.isEmpty(date)) {
            date = new Date();
        }
        timeType = StringUtil.ifEmptyOrNullReturnValue(timeType).toUpperCase();
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_HOUR:
                timeCode = getDateTime(date, COMMON_PATTERN_TO_HOUR);
                break;
            case TimeTypeConst.TIME_TYPE_DAY:
                timeCode = getDateTime(date, COMMON_PATTERN_TO_DAY);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                timeCode = getDateTime(date, COMMON_PATTERN_TO_MONTH);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                timeCode = getDateTime(date, COMMON_PATTERN_YEAR);
                break;
            default:
                break;
        }
        return timeCode;
    }

    /**
     * èŽ·å–时间对应的环比时间
     *
     * @param timeType HOUR/DAY/MONTH/YEAR
     * @param date     æ—¶é—´å€¼
     * @return
     */
    public static Date getLoopTime(String timeType, Date date) {
        Date dt = null;
        if (ObjectUtil.isEmpty(date)) {
            date = new Date();
        }
        timeType = StringUtil.ifEmptyOrNullReturnValue(timeType).toUpperCase();
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_HOUR:
                dt = addHours(date, CommonConst.DIGIT_MINUS_1);
                break;
            case TimeTypeConst.TIME_TYPE_DAY:
                dt = addDays(date, CommonConst.DIGIT_MINUS_1);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                dt = addMonths(date, CommonConst.DIGIT_MINUS_1);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                dt = addYears(date, CommonConst.DIGIT_MINUS_1);
                break;
            default:
                break;
        }
        return dt;
    }

    /**
     * èŽ·å–整点时间
     *
     * @param timeType HOUR/DAY/MONTH/YEAR
     * @param date     æ—¶é—´å€¼
     * @return
     */
    public static Date getHourTime(String timeType, Date date) {
        Date dt = null;
        if (ObjectUtil.isEmpty(date)) {
            date = new Date();
        }
        String tempStr = null;
        timeType = StringUtil.ifEmptyOrNullReturnValue(timeType).toUpperCase();
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_HOUR:
                tempStr = getDateTime(date, COMMON_PATTERN_TO_HOUR);
                dt = toDateTime(tempStr, COMMON_PATTERN_TO_HOUR);
                break;
            case TimeTypeConst.TIME_TYPE_DAY:
                tempStr = getDateTime(date, COMMON_PATTERN_TO_DAY);
                dt = toDateTime(tempStr, COMMON_PATTERN_TO_DAY);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                tempStr = getDateTime(date, COMMON_PATTERN_TO_MONTH);
                dt = toDateTime(tempStr, COMMON_PATTERN_TO_MONTH);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                tempStr = getDateTime(date, COMMON_PATTERN_YEAR);
                dt = toDateTime(tempStr, COMMON_PATTERN_YEAR);
                break;
            default:
                break;
        }
        return dt;
    }

    /**
     * è®¡ç®—两个时间间隔天数（日期格式比较）
     *
     * @param beginTime
     * @param endTime
     * @return
     */
    public static int daysBetween(Date beginTime, Date endTime) {
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(beginTime);
        long beginStamp = calendar.getTimeInMillis();
        calendar.setTime(endTime);
        long endStamp = calendar.getTimeInMillis();
        long betweenDays = (endStamp - beginStamp) / (1000 * 3600 * 24);
        return Integer.parseInt(String.valueOf(betweenDays));
    }

    /**
     * è®¡ç®—两个时间间隔天数（字符串格式比较）
     *
     * @param beginTime
     * @param endTime
     * @return
     */
    public static int daysBetween(String beginTime, String endTime) {
        try {
            SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
            Date begin = format.parse(beginTime);
            Date end = format.parse(endTime);
            return daysBetween(begin, end);
        } catch (ParseException exception) {
            log.error("计算两个时间间隔天数" + exception.getMessage());
            return 0;
        }
    }

    /**
     * æ ¹æ®æ—¶é—´ç±»åž‹æŠŠå­—符串转成对应的时间
     *
     * @param timeType æ—¶é—´ç±»åž‹
     * @param time     æ—¶é—´å­—符串
     * @return
     */
    public static Date getTime(String timeType, String time) {
        Date dt = null;
        timeType = StringUtil.ifEmptyOrNullReturnValue(timeType).toUpperCase();
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_HOUR:
                dt = toDateTime(time, COMMON_PATTERN_TO_HOUR);
                break;
            case TimeTypeConst.TIME_TYPE_DAY:
                dt = toDateTime(time, COMMON_PATTERN_TO_DAY);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                dt = toDateTime(time, COMMON_PATTERN_TO_MONTH);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                dt = toDateTime(time, COMMON_PATTERN_YEAR);
                break;
            default:
                break;
        }
        return dt;
    }

    /**
     * æ ¹æ®æ—¶é—´ç±»åž‹æŠŠè¿žç»­çš„日期字符串转成对应的时间 ï¼ˆ202303、20230303、2023030301、202303030101）
     *
     * @param timeType æ—¶é—´ç±»åž‹
     * @param time     æ—¶é—´å­—符串
     * @return
     */
    public static Date getTimeByContinuousTimeCode(String timeType, String time) {
        Date dt = null;
        timeType = StringUtil.ifEmptyOrNullReturnValue(timeType).toUpperCase();
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_HOUR:
                dt = toDateTime(time, COMMON_PATTERN_HOUR);
                break;
            case TimeTypeConst.TIME_TYPE_DAY:
                dt = toDateTime(time, COMMON_PATTERN_DAY);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                dt = toDateTime(time, COMMON_PATTERN_MONTH);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                dt = toDateTime(time, COMMON_PATTERN_YEAR);
                break;
            default:
                break;
        }
        return dt;
    }

    /**
     * æ ¹æ®æ—¶é—´ç±»åž‹è¿”回天、月、年最后的时间
     *
     * @param timeType æ—¶é—´ç±»åž‹
     * @param time     æ—¶é—´
     * @return
     */
    public static Date getEndTimeByType(String timeType, Date time) {
        Date dt = null;
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_DAY:
                dt = DateUtil.endOfDay(time);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                dt = DateUtil.endOfMonth(time);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                dt = DateUtil.endOfYear(time);
                break;
            default:
                break;
        }
        return dt;
    }

    /**
     * æ ¹æ®å‘¨æœŸç±»åž‹å¯¹ç”Ÿäº§å‘¨æœŸè¿›è¡ŒåŠ å‡è®¡ç®—
     * å¡«æŠ¥å‘¨æœŸç±»åž‹ï¼ˆHOUR小时、DAY天、MONTH月、YEAR年）
     *
     * @param date      ç”Ÿäº§å‘¨æœŸ
     * @param cycleType ç”Ÿäº§å‘¨æœŸç±»åž‹
     * @param cycleType ç”Ÿäº§å‘¨æœŸç±»åž‹
     * @param val è®¡ç®—值
     * @return
     */
    public static Date productionCycleCal(Date date, String cycleType,int val) {
        Date momDate = date;
        switch (cycleType) {
            case TimeTypeConst.TIME_TYPE_HOUR:
                momDate = DateUtils.addHours(date, val);
                break;
            case TimeTypeConst.TIME_TYPE_DAY:
                momDate = DateUtils.addDays(date, val);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                momDate = DateUtils.addMonths(date, val);
                break;
        }
        return momDate;
    }

    /**
     * æ ¹æ®å‘¨æœŸç±»åž‹å¯¹ç”Ÿäº§å‘¨æœŸè¿›è¡ŒåŠ å‡è®¡ç®— å¹¶ä¸”进位  ä¾‹å¦‚： HOUR +1进位就是 åŠ ä¸€å¤©
     * å¡«æŠ¥å‘¨æœŸç±»åž‹ï¼ˆHOUR小时、DAY天、MONTH月、YEAR年）
     *
     * @param date      ç”Ÿäº§å‘¨æœŸ
     * @param cycleType ç”Ÿäº§å‘¨æœŸç±»åž‹
     * @param val è®¡ç®—值
     * @return
     */
    public static Date productionCycleCalCarry(Date date, String cycleType,int val) {
        Date momDate = date;
        switch (cycleType) {
            case TimeTypeConst.TIME_TYPE_HOUR:
                momDate = DateUtils.addDays(date, val);
                break;
            case TimeTypeConst.TIME_TYPE_DAY:
                momDate = DateUtils.addMonths(date, val);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                momDate = DateUtils.addYears(date, val);
                break;
        }
        return momDate;
    }
}

 zhitan-common/src/main/java/com/zhitan/common/utils/DoubleUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,103 @@
package com.zhitan.common.utils;

import cn.hutool.core.util.ObjectUtil;

/**
 * @Description: æ•°å­—工具类
 * @author: yxw
 * @date: 2022å¹´02月07日 15:03
 */
public class DoubleUtil {
    public static double toDouble(String str) {
        double d = 0;
        try {
            d = Double.parseDouble(str);
        } catch (Exception e) {
            d = 0;
        }
        return d;
    }

    /**
     * long è½¬æˆ double类型
     *
     * @param l
     * @return
     */
    public static double toDouble(long l) {
        return toDouble(l + "");
    }

    /**
     * long è½¬æˆ double类型
     *
     * @param l
     * @return
     */
    public static double toDouble(Object l) {
        return toDouble(l + "");
    }

    /**
     * int è½¬æˆ double类型
     *
     * @param i
     * @return
     */
    public static double toDouble(int i) {
        return toDouble(i + "");
    }


    /**
     * æ ¼å¼åŒ–小数为指定位数的小数字符串
     *
     * @param value
     * @return
     */
    public static String formatDoubleToStr(Double value, int format) {
        if (ObjectUtil.isEmpty(value)) {
            value = 0.00;
        }
        String str = String.format("%." + format + "f", value).toString();
        return str;
    }

    /**
     * æ ¼å¼åŒ–小数为指定位数的小数字符串,默认格式化为2位小数
     *
     * @param value
     * @return
     */
    public static String formatDoubleToStr(Double value) {
        return formatDoubleToStr(value, 2);
    }

    /**
     * æ ¼å¼åŒ–小数为指定位数的小数
     *
     * @param value
     * @param format
     * @return
     */
    public static double formatDouble(Double value, int format) {
        if (ObjectUtil.isEmpty(value)) {
            return 0D;
        }
        String str = formatDoubleToStr(value, format);
        return toDouble(str);
    }

    /**
     * æ ¼å¼åŒ–小数为2位数的小数
     *
     * @param value
     * @return
     */
    public static double formatDouble(Double value) {
        if (ObjectUtil.isEmpty(value)) {
            return 0D;
        }
        return formatDouble(value, 2);
    }
}

 zhitan-common/src/main/java/com/zhitan/common/utils/IntegerUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,40 @@
package com.zhitan.common.utils;

/**
 * @Description: æ•´æ•°ç›¸å…³å·¥å…·ç±»
 * @author: yxw
 * @date: 2022å¹´03月10日 17:31
 */
public class IntegerUtil {
    /**
     * å­—符串转成int类型
     *
     * @param str
     * @return
     */
    public static int toInt(String str) {
        int d = 0;
        try {
            d = Integer.parseInt(str);
        } catch (Exception e) {
            d = 0;
        }
        return d;
    }

    /**
     * long转成int类型
     *
     * @param l
     * @return
     */
    public static int toInt(long l) {
        int d = 0;
        try {
            d = (int) l;
        } catch (Exception e) {
            d = 0;
        }
        return d;
    }
}

 zhitan-common/src/main/java/com/zhitan/common/utils/StringUtil.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,70 @@
package com.zhitan.common.utils;

import com.alibaba.fastjson.JSONObject;
import com.zhitan.common.constant.CommonConst;

/**
 * @Description: å­—符串工具类
 * @author: yxw
 * @date: 2022å¹´02月02日 12:27
 */
public class StringUtil {
    /**
     * åˆ¤æ–­å­—符串是否为空字符串或者Null
     *
     * @param str éœ€è¦åˆ¤æ–­çš„字符串
     * @return
     */
    public static boolean isEmptyOrNull(String str) {
        if (str == null || CommonConst.EMPTY.equals(str)) {
            return true;
        }
        return false;
    }

    /**
     * å­—符串如果为空字符串或者Null返回空字符串，否则返回字符串本身的值
     *
     * @param str
     * @return
     */
    public static String ifEmptyOrNullReturnValue(String str) {
        if (isEmptyOrNull(str)) {
            return CommonConst.EMPTY;
        }
        return str;
    }

    /**
     * å¯¹è±¡è½¬æˆjson字符串
     *
     * @param obj
     * @return
     */
    public static String toJson(Object obj) {
        return JSONObject.toJSONString(obj);
    }

    /**
     * å¯¹è±¡è½¬æˆJSONObject
     *
     * @param obj
     * @return
     */
    public static JSONObject toJsonObject(Object obj) {
        return JSONObject.parseObject(toJson(obj));
    }

    /**
     * é¦–字母大写
     *
     * @param str
     * @return
     */
    public static String captureWord(String str) {
        str = str.toLowerCase();
        char[] cs = str.toCharArray();
        cs[0] -= 32;
        return String.valueOf(cs);
    }
}

 zhitan-system/src/main/java/com/zhitan/comprehensivestatistics/mapper/DailyComprehensiveMapper.java

@@ -14,7 +14,7 @@
 * @date 2020-03-25
 */
public interface DailyComprehensiveMapper {
    public List<DailyComprehensive> getDailyComprehensiveList(@Param("nodeId") String nodeId,
    List<DailyComprehensive> getDailyComprehensiveList(@Param("nodeId") String nodeId,
                                                              @Param("dataList") List<DailyComprehensive> dataList,
                                                              @Param("beginTime") Date beginTime,
                                                              @Param("endTime") Date endTime,

 zhitan-system/src/main/java/com/zhitan/dataitem/domain/vo/NodeIndexValueVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,32 @@
package com.zhitan.dataitem.domain.vo;

import lombok.Data;

import java.math.BigDecimal;

/**
 * @Author DYL
 **/
@Data
public class NodeIndexValueVO {

    /**
     * èŠ‚点id
     */
    private String nodeId;

    /**
     * èŠ‚点名称
     */
    private String nodeName;

    /**
     * ç‚¹ä½id
     */
    private String indexId;

    /**
     * ç´¯ç§¯é‡
     */
    private BigDecimal value;
}

 zhitan-system/src/main/java/com/zhitan/dataitem/mapper/DataItemMapper.java

@@ -1,5 +1,6 @@
package com.zhitan.dataitem.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zhitan.carbonemission.domain.CarbonEmission;
import com.zhitan.common.enums.TimeType;
import com.zhitan.dataitem.domain.StagseDataEntry;
@@ -16,7 +17,7 @@
 * @author sys
 * @date 2020-03-25
 */
public interface DataItemMapper {
public interface DataItemMapper extends BaseMapper<DataItem> {
    /**
     * é˜¶æ®µæ•°æ®å½•å…¥
     *

 zhitan-system/src/main/java/com/zhitan/dataitem/service/IDataItemService.java

@@ -4,6 +4,8 @@
import com.zhitan.common.enums.TimeType;
import com.zhitan.dataitem.domain.StagseDataEntry;
import com.zhitan.realtimedata.domain.DataItem;
import com.zhitan.statisticalAnalysis.domain.dto.FlowChartsDTO;
import com.zhitan.statisticalAnalysis.domain.vo.FlowChartsVO;

import java.math.BigDecimal;
import java.util.Date;
@@ -88,4 +90,12 @@
     * @return
     */
    List<DataItem> getDataItemHourInforByIndexIds(Date beginTime, Date endTime, String timeType, List<String> indexIds);

    /**
     * èŽ·å–能流图形分析
     *
     * @param dto è¯·æ±‚参数
     * @return ç»“æžœ
     */
    FlowChartsVO getFlowCharts(FlowChartsDTO dto);
}

 zhitan-system/src/main/java/com/zhitan/dataitem/service/impl/DataItemServiceImpl.java

@@ -2,15 +2,29 @@

import com.zhitan.common.enums.TimeType;
import com.zhitan.dataitem.domain.StagseDataEntry;
import com.zhitan.dataitem.domain.vo.NodeIndexValueVO;
import com.zhitan.dataitem.mapper.DataItemMapper;
import com.zhitan.dataitem.service.IDataItemService;
import com.zhitan.model.domain.ModelNode;
import com.zhitan.model.mapper.EnergyIndexMapper;
import com.zhitan.model.mapper.ModelNodeMapper;
import com.zhitan.model.mapper.NodeIndexMapper;
import com.zhitan.realtimedata.domain.DataItem;
import com.zhitan.statisticalAnalysis.domain.dto.FlowChartsDTO;
import com.zhitan.statisticalAnalysis.domain.vo.FlowChartsItemVO;
import com.zhitan.statisticalAnalysis.domain.vo.FlowChartsVO;
import lombok.AllArgsConstructor;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.temporal.TemporalAdjusters;
import java.util.*;
import java.util.stream.Collectors;

/**
 * stagseDataEntryService业务层处理
@@ -22,7 +36,14 @@
@AllArgsConstructor
public class DataItemServiceImpl implements IDataItemService {

    private final DataItemMapper dataItemMapper;
    @Resource
    private DataItemMapper dataItemMapper;
    @Resource
    private ModelNodeMapper modelNodeMapper;
    @Resource
    private EnergyIndexMapper energyIndexMapper;
    @Resource
    private NodeIndexMapper nodeIndexMapper;


    /**
@@ -117,4 +138,116 @@
    public List<DataItem> getDataItemHourInforByIndexIds(Date beginTime, Date endTime, String timeType, List<String> indexIds) {
        return dataItemMapper.getDataItemHourInforByIndexIds(beginTime, endTime, timeType, indexIds);
    }

    /**
     * èŽ·å–能流图形分析
     *
     * @param dto è¯·æ±‚参数
     * @return ç»“æžœ
     */
    @Override
    public FlowChartsVO getFlowCharts(FlowChartsDTO dto) {
        FlowChartsVO flowChartsVO = new FlowChartsVO();
        // çˆ¶èŠ‚点id
        String nodeId = dto.getNodeId();
        String energyType = dto.getEnergyType();
        LocalDate queryTime = dto.getQueryTime();
        TimeType timeType = dto.getTimeType();

        // èŽ·å–节点信息
        ModelNode modelNode = modelNodeMapper.selectModelNodeById(nodeId);
        if (ObjectUtils.isEmpty(modelNode)) {
            return flowChartsVO;
        }
        // èŽ·å–查询时间
        Map<String, LocalDateTime> dateTimeMap = getDataItemByIndexId(timeType, queryTime);

        // èŽ·å–节点和点位的累积量
        List<NodeIndexValueVO> parentDataItemList = modelNodeMapper.getDataItemByNodeId(nodeId, energyType, timeType, dateTimeMap);

        // èŽ·å–子节点下的点位的累积量
        List<NodeIndexValueVO> childDataItemList = modelNodeMapper.getDataItemByParentNodeId(nodeId, energyType, timeType, dateTimeMap);

        // èŽ·å–父节点下的能耗数据总和
        if (ObjectUtils.isNotEmpty(parentDataItemList)) {
            // çˆ¶èŠ‚点下的能耗数据总和
            BigDecimal totalValue = parentDataItemList.stream().map(NodeIndexValueVO::getValue)
                    .filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add);
            // æ€»ç´¯ç§¯é‡
            flowChartsVO.setTotalAccumulatedAmount(totalValue);
        }
        // èŽ·å–子节点下的能耗数据
        if (ObjectUtils.isNotEmpty(childDataItemList)) {
            // å­èŠ‚点下的能耗数据总和
            BigDecimal childTotalValue = childDataItemList.stream().map(NodeIndexValueVO::getValue)
                    .filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add);
            // å­èŠ‚点累积量
            flowChartsVO.setChildNodeAccumulatedAmount(childTotalValue);

            // æ ¹æ®å­èŠ‚点id分组
            Map<String, List<NodeIndexValueVO>> voMap = childDataItemList.stream()
                    .collect(Collectors.groupingBy(NodeIndexValueVO::getNodeId));
            List<FlowChartsItemVO> itemList = new ArrayList<>();

            for (String childNodeId : voMap.keySet()) {
                FlowChartsItemVO vo = new FlowChartsItemVO();
                vo.setSource(modelNode.getName());
                List<NodeIndexValueVO> valueList = voMap.getOrDefault(childNodeId, Collections.emptyList());
                if (ObjectUtils.isNotEmpty(valueList)) {
                    // å„个子节点的能耗数据总和
                    BigDecimal value = valueList.stream().map(NodeIndexValueVO::getValue)
                            .filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add);
                    valueList.stream().findFirst().ifPresent(nodeIndexValueVO -> vo.setTarget(nodeIndexValueVO.getNodeName()));
                    vo.setValue(value);
                }
                itemList.add(vo);
            }
            flowChartsVO.setItemVOList(itemList);
        }
        return flowChartsVO;
    }

    /**
     * æ ¹æ®indexId查询能耗数据
     */
    private Map<String, LocalDateTime> getDataItemByIndexId(TimeType timeType, LocalDate queryTime) {
        LocalDateTime startTime;
        LocalDateTime endTime;
        LocalDate startDate;
        LocalDate endDate;
        switch (timeType) {
            case DAY:
                // å½“天的开始时间
                startTime = LocalDateTime.of(queryTime, LocalTime.MIN);
                // å½“天的结束时间
                endTime = LocalDateTime.of(queryTime, LocalTime.MAX);
                break;
            case MONTH:
                // å½“月的开始时间
                startDate = queryTime.with(TemporalAdjusters.firstDayOfMonth());
                startTime = LocalDateTime.of(startDate, LocalTime.MIN);
                // å½“月的结束时间
                endDate = queryTime.with(TemporalAdjusters.lastDayOfMonth());
                endTime = LocalDateTime.of(endDate, LocalTime.MAX);
                break;
            case YEAR:
                // å½“年的开始时间
                startDate = queryTime.with(TemporalAdjusters.firstDayOfYear());
                startTime = LocalDateTime.of(startDate, LocalTime.MIN);
                // å½“年的结束时间
                endDate = queryTime.with(TemporalAdjusters.lastDayOfYear());
                endTime = LocalDateTime.of(endDate, LocalTime.MAX);
                break;
            default:
                // å½“天的开始时间
                startTime = LocalDateTime.of(queryTime, LocalTime.MIN);
                // å½“天的结束时间
                endTime = LocalDateTime.of(queryTime, LocalTime.MAX);
                break;
        }
        Map<String, LocalDateTime> localDateTimeMap = new HashMap<>();
        localDateTimeMap.put("startTime", startTime);
        localDateTimeMap.put("endTime", endTime);
        return localDateTimeMap;
    }
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/EnergyUnitToDevice.java

ÎļþÒÑɾ³ý

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ElectricPowerFactorDetail.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,33 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´04月24日 16:59
 */
@Data
public class ElectricPowerFactorDetail {
    /**
     * æœ€å¤§åŠŸçŽ‡å› æ•°
     */
    private String max;
    /**
     * æœ€å¤§åŠŸçŽ‡å› æ•°å‘生时间
     */
    private String maxTime;
    /**
     * æœ€å°åŠŸçŽ‡å› æ•°
     */
    private String min;
    /**
     * æœ€å°åŠŸçŽ‡å› æ•°å‘生时间
     */
    private String minTime;
    /**
     * å¹³å‡åŠŸçŽ‡å› æ•°
     */
    private String avg;

}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ElectricPowerFactorItem.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,20 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´04月24日 16:59
 */
@Data
public class ElectricPowerFactorItem {
    /**
     * æ—¶é—´
     */
    private String timeCode;
    /**
     * å®žæ—¶å€¼
     */
    private String value;
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ElectricPowerFactorVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,23 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

import java.util.List;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´04月24日 16:58
 */
@Data
public class ElectricPowerFactorVO {
    /**
     * è®°å½•åˆ—表
     */
    private List<ElectricPowerFactorItem> itemList;

    /**
     * è¯¦æƒ…实体
     */
    private ElectricPowerFactorDetail detail;
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ElectricThreePhaseDetail.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,55 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´04月24日 16:59
 */
@Data
public class ElectricThreePhaseDetail {
    /**
     * æœ€å¤§åŠŸçŽ‡å› æ•°
     */
    private String max;
    /**
     * æœ€å¤§åŠŸçŽ‡å› æ•°å‘生时间
     */
    private String maxTime;
    /**
     * æœ€å°åŠŸçŽ‡å› æ•°
     */
    private String min;
    /**
     * æœ€å°åŠŸçŽ‡å› æ•°å‘生时间
     */
    private String minTime;

    /**
     * æœ€å¤§å€¼-A相电流/电压
     */
    private String valueMaxA;
    /**
     * æœ€å¤§å€¼-B相电流/电压
     */
    private String valueMaxB;
    /**
     * æœ€å¤§å€¼-C相电流/电压
     */
    private String valueMaxC;

    /**
     * æœ€å°å€¼-A相电流/电压
     */
    private String valueMinA;
    /**
     * æœ€å°å€¼-B相电流/电压
     */
    private String valueMinB;
    /**
     * æœ€å°å€¼-C相电流/电压
     */
    private String valueMinC;

}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ElectricThreePhaseItem.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´04月24日 16:59
 */
@Data
public class ElectricThreePhaseItem {
    /**
     * ç”µè¡¨åç§°
     */
    private String name;
    /**
     * æ—¶é—´
     */
    private String timeCode;
    /**
     * ç»Ÿè®¡å›¾æ˜¾ç¤ºæ—¶é—´
     */
    private String timeCodeChart;
    /**
     * æœ€å¤§ä¸‰ç›¸ä¸å¹³è¡¡
     */
    private String max;
    /**
     * æœ€å°ä¸‰ç›¸ä¸å¹³è¡¡
     */
    private String min;
    /**
     * A相电流/电压
     */
    private String valueA;
    /**
     * D相电流/电压
     */
    private String valueB;
    /**
     * C相电流/电压
     */
    private String valueC;
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ElectricThreePhaseTempModel.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

import java.util.Date;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´05月06日 14:02
 */
@Data
public class ElectricThreePhaseTempModel {

    private Double max;
    private Date maxTime;
    private Double min;
    private Date minTime;
    /**
     * æœ€å¤§å€¼-A相电流/电压
     */
    private double valueMaxA;
    /**
     * æœ€å¤§å€¼-B相电流/电压
     */
    private double valueMaxB;
    /**
     * æœ€å¤§å€¼-C相电流/电压
     */
    private double valueMaxC;

    /**
     * æœ€å°å€¼-A相电流/电压
     */
    private double valueMinA;
    /**
     * æœ€å°å€¼-B相电流/电压
     */
    private double valueMinB;
    /**
     * æœ€å°å€¼-C相电流/电压
     */
    private double valueMinC;
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ElectricThreePhaseVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,23 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

import java.util.List;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´04月24日 16:58
 */
@Data
public class ElectricThreePhaseVO {
    /**
     * è®°å½•åˆ—表
     */
    private List<ElectricThreePhaseItem> itemList;

    /**
     * è¯¦æƒ…实体
     */
    private ElectricThreePhaseDetail detail;
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/EnergyIndexAndUnitDevice.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,20 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

/**
 * é‡‡é›†ç‚¹ç”¨èƒ½å•å…ƒç”µè¡¨
 *
 * @author fanxinfu
 */
@Data
public class EnergyIndexAndUnitDevice {

  private String indexId;
  private String indexName;
  private String energyType;
  private String energyName;
  private String energyUnitName;
  private String energyUnitDeviceName;

}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/EnergyIndexInforModel.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,33 @@
package com.zhitan.energyMonitor.domain.vo;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;


/**
 * ç‚¹ä½è¯¦ç»†ä¿¡æ¯
 *
 * @Author: Zhujw
 * @Date: 2023/5/26
 */
@Data
public class EnergyIndexInforModel {

  @ApiModelProperty(value = "点位id")
  private String indexId;

  @ApiModelProperty(value = "计量器具id")
  private String meterId;

  @ApiModelProperty(value = "点位名称")
  private String indexName;

  @ApiModelProperty(value = "点位类型(采集、计算)")
  private String indexType;

  @ApiModelProperty(value = "点位code")
  private String indexCode;

  @ApiModelProperty(value = "点位单位")
  private String indexUnit;
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ListElectricLoadDetail.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,36 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´04月24日 16:59
 */
@Data
public class ListElectricLoadDetail {
    /**
     * æœ€å¤§è´Ÿè·
     */
    private String max;
    /**
     * æœ€å¤§è´Ÿè·å‘生时间
     */
    private String maxTime;
    /**
     * æœ€å°è´Ÿè·
     */
    private String min;
    /**
     * æœ€å°è´Ÿè·å‘生时间
     */
    private String minTime;
    /**
     * å¹³å‡è´Ÿè·
     */
    private String avg;
    /**
     * è´Ÿè·çŽ‡ = å¹³å‡è´Ÿè· / æœ€å¤§è´Ÿè·
     */
    private String rate;
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ListElectricLoadItem.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,44 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´04月24日 16:59
 */
@Data
public class ListElectricLoadItem {
    /**
     * ç”µè¡¨åç§°
     */
    private String name;
    /**
     * æ—¶é—´
     */
    private String timeCode;
    /**
     * ç»Ÿè®¡å›¾æ˜¾ç¤ºæ—¶é—´
     */
    private String timeCodeChart;
    /**
     * æœ€å¤§è´Ÿè·
     */
    private String max;
    /**
     * æœ€å°è´Ÿè·
     */
    private String min;
    /**
     * å¹³å‡è´Ÿè·
     */
    private String avg;
    /**
     * å®žæ—¶å€¼
     */
    private String value;
    /**
     * è´Ÿè·çŽ‡
     */
    private String rate;
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/domain/vo/ListElectricLoadVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,23 @@
package com.zhitan.energyMonitor.domain.vo;

import lombok.Data;

import java.util.List;

/**
 * @Description: TODO
 * @author: yxw
 * @date: 2022å¹´04月24日 16:58
 */
@Data
public class ListElectricLoadVO {
    /**
     * è®°å½•åˆ—表
     */
    private List<ListElectricLoadItem> itemList;

    /**
     * è¯¦æƒ…实体
     */
    private ListElectricLoadDetail detail;
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/mapper/EnergyUnitToDeviceMapper.java

ÎļþÒÑɾ³ý

 zhitan-system/src/main/java/com/zhitan/energyMonitor/service/IElectricLoadService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,18 @@
package com.zhitan.energyMonitor.service;

import com.zhitan.energyMonitor.domain.vo.ListElectricLoadVO;
import com.zhitan.model.domain.EnergyIndex;

/**
 * @Description:
 * @Author: jeecg-boot
 * @Date: 2022-04-19
 * @Version: V1.0
 */
public interface IElectricLoadService {

    /**
     * èŽ·å–负荷分析数据
     */
    ListElectricLoadVO list(String timeType, String timeCode, EnergyIndex energyIndex);
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/service/IElectricPowerFactorService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,19 @@
package com.zhitan.energyMonitor.service;

import com.zhitan.energyMonitor.domain.vo.ElectricPowerFactorVO;
import com.zhitan.model.domain.EnergyIndex;


/**
 * @Description:
 * @Author: jeecg-boot
 * @Date: 2022-04-19
 * @Version: V1.0
 */
public interface IElectricPowerFactorService {

    /**
     * èŽ·å–负荷分析数据
     */
    ElectricPowerFactorVO list(String timeCode, EnergyIndex energyIndex);
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/service/IElectricThreePhaseService.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,20 @@
package com.zhitan.energyMonitor.service;

import com.zhitan.energyMonitor.domain.vo.ElectricThreePhaseVO;
import com.zhitan.model.domain.EnergyIndex;

import java.util.List;

/**
 * @Description:
 * @Author: jeecg-boot
 * @Date: 2022-04-19
 * @Version: V1.0
 */
public interface IElectricThreePhaseService {

    /**
     * èŽ·å–三相不平衡数据
     */
    ElectricThreePhaseVO list(String timeType, String timeCode, List<EnergyIndex> energyIndexList, String requestType, String meterId);
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/service/IEnergyUnitToDeviceService.java

ÎļþÒÑɾ³ý

 zhitan-system/src/main/java/com/zhitan/energyMonitor/service/impl/ElectricLoadServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,258 @@
package com.zhitan.energyMonitor.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.zhitan.basicdata.domain.MeterImplement;
import com.zhitan.basicdata.mapper.MeterImplementMapper;
import com.zhitan.common.constant.CommonConst;
import com.zhitan.common.constant.TimeTypeConst;
import com.zhitan.common.enums.CollectionModes;
import com.zhitan.common.enums.GroupTimeType;
import com.zhitan.common.utils.ChartUtils;
import com.zhitan.common.utils.DateTimeUtil;
import com.zhitan.common.utils.DoubleUtil;
import com.zhitan.common.utils.StringUtil;
import com.zhitan.energyMonitor.domain.vo.ListElectricLoadDetail;
import com.zhitan.energyMonitor.domain.vo.ListElectricLoadItem;
import com.zhitan.energyMonitor.domain.vo.ListElectricLoadVO;
import com.zhitan.energyMonitor.service.IElectricLoadService;
import com.zhitan.model.domain.EnergyIndex;
import com.zhitan.realtimedata.domain.TagValue;
import com.zhitan.realtimedata.service.RealtimeDatabaseService;
import org.apache.commons.lang3.ObjectUtils;
import org.joda.time.DateTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @Description: sensor_alarm_item
 * @Author: jeecg-boot
 * @Date: 2022-04-19
 * @Version: V1.0
 */
@Service
public class ElectricLoadServiceImpl implements IElectricLoadService {
    @Autowired
    private RealtimeDatabaseService realtimeDatabaseService;
    @Resource
    private MeterImplementMapper meterImplementMapper;

    @Override
    public ListElectricLoadVO list(String timeType, String timeCode, EnergyIndex energyIndex) {
        ListElectricLoadVO vo = new ListElectricLoadVO();
        List<ListElectricLoadItem> itemList = new ArrayList<>();
        vo.setItemList(itemList);
        ListElectricLoadDetail detail = new ListElectricLoadDetail();
        detail.setMaxTime(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setMax(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setMin(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setMinTime(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setAvg(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setRate(CommonConst.DOUBLE_MINUS_SIGN);
        vo.setDetail(detail);

        MeterImplement meterImplement = meterImplementMapper.selectById(energyIndex.getMeterId());

        if (ObjectUtil.isEmpty(meterImplement)) {
            return vo;
        }
        List<Date> dateList = new ArrayList<>();
        ChartUtils.generateDateList(timeType, timeCode, dateList);
        // å› ä¸ºinfluxdb没有按照月分组取数据，只能按照日期循环取数据
        if (TimeTypeConst.TIME_TYPE_YEAR.equals(timeType)) {
            getYearData(timeType, dateList, energyIndex, meterImplement.getMeterName(), itemList);
        } else {
            getDayAndMonthData(timeType, timeCode, energyIndex, meterImplement.getMeterName(), itemList);
        }
        if (!StringUtil.isEmptyOrNull(energyIndex.getCode())) {
            Date start = ChartUtils.getDateTime(timeType, timeCode);
            Date end = ChartUtils.getEndTime(timeType, start);

            String code = energyIndex.getCode();
            TagValue maxTagValueModel = realtimeDatabaseService.statistics(code, start, end, CollectionModes.max);
            TagValue minTagValueModel = realtimeDatabaseService.statistics(code, start, end, CollectionModes.min);
            TagValue avgTagValueModel = realtimeDatabaseService.statistics(code, start, end, CollectionModes.mean);

            double avg = CommonConst.DIGIT_DOUBLE_0;
            if (!ObjectUtil.isEmpty(avgTagValueModel) && !ObjectUtil.isEmpty(avgTagValueModel.getValue())) {
                detail.setAvg(DoubleUtil.formatDoubleToStr(avgTagValueModel.getValue()) + CommonConst.ELECTRIC_LOAD_UNIT);
                avg = avgTagValueModel.getValue();
            }

            if (!ObjectUtil.isEmpty(maxTagValueModel) && !ObjectUtil.isEmpty(maxTagValueModel.getValue())) {
                detail.setMax(DoubleUtil.formatDoubleToStr(maxTagValueModel.getValue()));
                detail.setMaxTime(DateTimeUtil.getDateTime(maxTagValueModel.getDataTime(), DateTimeUtil.COMMON_PATTERN));

                if (maxTagValueModel.getValue() != CommonConst.DIGIT_DOUBLE_0) {
                    double rate = avg * CommonConst.DIGIT_DOUBLE_100 / maxTagValueModel.getValue();
                    detail.setRate(DoubleUtil.formatDoubleToStr(rate) + CommonConst.SYMBOL_PERCENT);
                }
            }

            if (!ObjectUtil.isEmpty(minTagValueModel) && !ObjectUtil.isEmpty(minTagValueModel.getValue())) {
                detail.setMin(DoubleUtil.formatDoubleToStr(minTagValueModel.getValue()));
                detail.setMinTime(DateTimeUtil.getDateTime(minTagValueModel.getDataTime(), DateTimeUtil.COMMON_PATTERN));
            }

            if (!CommonConst.DOUBLE_MINUS_SIGN.equals(detail.getMax())) {
                String m = detail.getMax();
                detail.setMax(m + CommonConst.ELECTRIC_LOAD_UNIT);
            }
            if (!CommonConst.DOUBLE_MINUS_SIGN.equals(detail.getMin())) {
                String min = detail.getMin();
                detail.setMin(min + CommonConst.ELECTRIC_LOAD_UNIT);
            }
            if (CommonConst.DOUBLE_MINUS_SIGN.equals(detail.getMax())) {
                detail.setAvg(CommonConst.DOUBLE_MINUS_SIGN);
            }
        }

        return vo;
    }

    /**
     * èŽ·å–月和天数据,因为influxdb可以按照分。时。天分组取数，不可以按照月分组取数，所以分成两个方法来写
     */
    private void getDayAndMonthData(String timeType, String timeCode, EnergyIndex energyIndex, String meterName, List<ListElectricLoadItem> itemList) {
        String tagCodes = energyIndex.getCode();
        List<TagValue> maxList = new ArrayList<>();
        List<TagValue> minList = new ArrayList<>();
        List<TagValue> avgList = new ArrayList<>();
        if (TimeTypeConst.TIME_TYPE_DAY.equals(timeType)) {
        } else {
            String tempTimeCode = StringUtil.ifEmptyOrNullReturnValue(timeCode).replace(CommonConst.SINGLE_MINUS_SIGN, CommonConst.EMPTY);
            Date start = DateTimeUtil.toDateTime(tempTimeCode, DateTimeUtil.COMMON_PATTERN_MONTH);
            Date end = DateTimeUtil.addMonths(start, CommonConst.DIGIT_1);
            if (!StringUtil.isEmptyOrNull(tagCodes)) {
                maxList = realtimeDatabaseService.statistics(tagCodes, start, end, CollectionModes.max, GroupTimeType.d);
                minList = realtimeDatabaseService.statistics(tagCodes, start, end, CollectionModes.min, GroupTimeType.d);
                avgList = realtimeDatabaseService.statistics(tagCodes, start, end, CollectionModes.mean, GroupTimeType.d);
            }
        }
        if (CollectionUtils.isEmpty(maxList)) {
            maxList = new ArrayList<>();
        }
        if (CollectionUtils.isEmpty(minList)) {
            minList = new ArrayList<>();
        }
        if (CollectionUtils.isEmpty(avgList)) {
            avgList = new ArrayList<>();
        }
        List<Date> dateList = new ArrayList<>();
        ChartUtils.generateDateList(timeType, timeCode, dateList);
        Date now = new Date();
        Date temNow = now;
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_DAY:
                //当前时间转成整时整点
                temNow = DateTimeUtil.getHourTime(TimeTypeConst.TIME_TYPE_HOUR, now);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                //当前时间转成整时整点
                temNow = DateTimeUtil.getHourTime(TimeTypeConst.TIME_TYPE_DAY, now);
                break;
            default:
                break;
        }
        for (Date date : dateList) {
            ListElectricLoadItem temp = new ListElectricLoadItem();
            temp.setTimeCode(ChartUtils.getTimeCode(timeType, date));
            temp.setName(ObjectUtils.isNotEmpty(meterName) ? meterName : "");
            temp.setMax(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setMin(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setAvg(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setTimeCodeChart(ChartUtils.getTimeCodeChart(timeType, date));
            temp.setRate(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setValue(CommonConst.DOUBLE_MINUS_SIGN);
            itemList.add(temp);
            // å¦‚果大于当前时间默认--
            if (DateTimeUtil.compareDateDiff(date, temNow) > CommonConst.DIGIT_0) {
                continue;
            }
            //天的判断
            if (TimeTypeConst.TIME_TYPE_DAY.equals(timeType)) {
                // ç”±äºŽå®žæ—¶åº“返回的时间对应值代表的是前一个周期的值
                Date nextHour = DateTimeUtil.addHours(date, CommonConst.DIGIT_1);
                if (!StringUtil.isEmptyOrNull(energyIndex.getCode())) {
                    TagValue tagValue = realtimeDatabaseService.retrieve(energyIndex.getCode(), nextHour);
                    if (!ObjectUtil.isEmpty(tagValue)) {
                        if (ObjectUtils.isEmpty(tagValue) || ObjectUtils.isEmpty(tagValue.getValue())) {
                            temp.setValue(CommonConst.DOUBLE_MINUS_SIGN);
                        } else {
                            temp.setValue(String.valueOf(DoubleUtil.formatDouble(tagValue.getValue())));
                        }
                    }
                }
            } else {
                //月的判断，由于实时库返回的时间对应值代表的是前一个周期的值
                Date nextDay = DateTimeUtil.addDays(date, CommonConst.DIGIT_1);
                TagValue tagValueMonth = maxList.stream().filter(x -> (new DateTime(x.getDataTime())).withTimeAtStartOfDay().toDate().equals(nextDay)).findAny().orElse(null);
                if (!ObjectUtil.isEmpty(tagValueMonth)) {
                    //月的找天
                    TagValue minModel = minList.stream().filter(x -> x.getDataTime().equals(tagValueMonth.getDataTime())).findAny().orElse(null);
                    if (!ObjectUtil.isEmpty(minModel)) {
                        temp.setMin(String.valueOf(DoubleUtil.formatDouble(minModel.getValue())));
                    }
                    TagValue avgModel = avgList.stream().filter(x -> x.getDataTime().equals(tagValueMonth.getDataTime())).findAny().orElse(null);
                    if (!ObjectUtil.isEmpty(avgModel)) {
                        temp.setAvg(String.valueOf(DoubleUtil.formatDouble(avgModel.getValue())));
                    }
                    temp.setMax(String.valueOf(DoubleUtil.formatDouble(tagValueMonth.getValue())));

                    temp.setRate(CommonConst.DOUBLE_MINUS_SIGN);
                    if (Double.parseDouble(temp.getMax()) != CommonConst.DIGIT_DOUBLE_0) {
                        double rate = Double.parseDouble(temp.getAvg()) * 100 / Double.parseDouble(temp.getMax());
                        temp.setRate(DoubleUtil.formatDoubleToStr(rate) + CommonConst.SYMBOL_PERCENT);
                    }
                }
            }
        }
    }

    /**
     * èŽ·å–年数据
     */
    private void getYearData(String timeType, List<Date> dateList, EnergyIndex energyIndex, String meterName, List<ListElectricLoadItem> itemList) {
        String tagCode = StringUtil.ifEmptyOrNullReturnValue(energyIndex.getCode());
        for (Date date : dateList) {
            ListElectricLoadItem temp = new ListElectricLoadItem();
            Date endTime = DateTimeUtil.addMonths(date, CommonConst.DIGIT_1);
            temp.setAvg(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setMax(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setMin(CommonConst.DOUBLE_MINUS_SIGN);
            if (!StringUtil.isEmptyOrNull(tagCode)) {
                String code = energyIndex.getCode();
                TagValue rt3 = realtimeDatabaseService.statistics(code, date, endTime, CollectionModes.max);
                TagValue rt4 = realtimeDatabaseService.statistics(code, date, endTime, CollectionModes.min);
                TagValue rt2 = realtimeDatabaseService.statistics(code, date, endTime, CollectionModes.mean);
                if (ObjectUtils.isNotEmpty(rt2.getValue())) {
                    temp.setAvg(String.valueOf(DoubleUtil.formatDouble(rt2.getValue())));
                }
                if (ObjectUtils.isNotEmpty(rt3.getValue())) {
                    temp.setMax(String.valueOf(DoubleUtil.formatDouble(rt3.getValue())));
                }
                if (ObjectUtils.isNotEmpty(rt4.getValue())) {
                    temp.setMin(String.valueOf(DoubleUtil.formatDouble(rt4.getValue())));
                }
            }

            temp.setTimeCode(ChartUtils.getTimeCode(timeType, date));
            temp.setTimeCodeChart(ChartUtils.getTimeCodeChart(timeType, date));
            temp.setName(StringUtil.ifEmptyOrNullReturnValue(meterName));
            temp.setRate(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setValue(CommonConst.DOUBLE_MINUS_SIGN);
            if (!temp.getMax().equals(CommonConst.DOUBLE_MINUS_SIGN) && Double.parseDouble(temp.getMax()) != CommonConst.DIGIT_DOUBLE_0) {
                double rate = Double.parseDouble(temp.getAvg()) * 100 / Double.parseDouble(temp.getMax());
                temp.setRate(DoubleUtil.formatDoubleToStr(rate) + CommonConst.SYMBOL_PERCENT);
            }
            itemList.add(temp);
        }
    }


}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/service/impl/ElectricPowerFactorServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,115 @@
package com.zhitan.energyMonitor.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.zhitan.common.constant.CommonConst;
import com.zhitan.common.constant.TimeTypeConst;
import com.zhitan.common.utils.ChartUtils;
import com.zhitan.common.utils.DateTimeUtil;
import com.zhitan.common.utils.DoubleUtil;
import com.zhitan.energyMonitor.domain.vo.ElectricPowerFactorDetail;
import com.zhitan.energyMonitor.domain.vo.ElectricPowerFactorItem;
import com.zhitan.energyMonitor.domain.vo.ElectricPowerFactorVO;
import com.zhitan.energyMonitor.service.IElectricPowerFactorService;
import com.zhitan.model.domain.EnergyIndex;
import com.zhitan.realtimedata.domain.TagValue;
import com.zhitan.realtimedata.service.RealtimeDatabaseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @Description: sensor_alarm_item
 * @Author: jeecg-boot
 * @Date: 2022-04-19
 * @Version: V1.0
 */
@Slf4j
@Service
public class ElectricPowerFactorServiceImpl implements IElectricPowerFactorService {
    @Autowired
    private RealtimeDatabaseService realtimeDatabaseService;

    @Override
    public ElectricPowerFactorVO list(String timeCode, EnergyIndex energyIndex) {
        ElectricPowerFactorVO vo = new ElectricPowerFactorVO();
        List<ElectricPowerFactorItem> itemList = new ArrayList<>();
        ElectricPowerFactorDetail detail = new ElectricPowerFactorDetail();
        detail.setMaxTime(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setMax(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setMin(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setMinTime(CommonConst.DOUBLE_MINUS_SIGN);
        vo.setItemList(itemList);
        vo.setDetail(detail);

        List<Date> dateList = new ArrayList<>();
        ChartUtils.generateDateList(TimeTypeConst.TIME_TYPE_DAY, timeCode, dateList);
        double max = CommonConst.DIGIT_0, min = CommonConst.MIN_INIT_VALUE;
        //dateList计数
        Date now = new Date();
        //当前时间转成整时整点
        now = DateTimeUtil.getHourTime(TimeTypeConst.TIME_TYPE_HOUR, now);
        int i = CommonConst.DIGIT_0;
        for (Date date : dateList) {
            ElectricPowerFactorItem temp = new ElectricPowerFactorItem();
            temp.setTimeCode(ChartUtils.getTimeCodeChart(TimeTypeConst.TIME_TYPE_DAY, date));
            temp.setValue(CommonConst.DOUBLE_MINUS_SIGN);
            itemList.add(temp);
            // å¦‚果大于当前时间默认--
            if (DateTimeUtil.compareDateDiff(date, now) > CommonConst.DIGIT_0) {
                i++;
                continue;
            }
            TagValue tagValue = new TagValue();
            try {
                TagValue retrieve = realtimeDatabaseService.retrieve(energyIndex.getCode(), date);
                if (ObjectUtil.isNotEmpty(retrieve)) {
                    tagValue = retrieve;
                }
            } catch (Exception e) {
                log.error("获取功率因数异常：" + e.getMessage());
            }
            if (ObjectUtil.isNotEmpty(tagValue.getValue())) {
                double value = DoubleUtil.formatDouble(tagValue.getValue());

                temp.setValue(String.valueOf(value));
                //给最小值赋值第一条
                if (i == CommonConst.DIGIT_0) {
                    min = Double.parseDouble(temp.getValue());
                }
                if (value > max) {
                    max = value;
                    detail.setMax(max + CommonConst.EMPTY);
                    detail.setMaxTime(DateTimeUtil.getDateTime(date));
                }
                if (value <= min) {
                    min = value;
                    detail.setMin(min + CommonConst.EMPTY);
                    detail.setMinTime(DateTimeUtil.getDateTime(date));
                }
            }
            i++;
        }

        detail.setAvg(CommonConst.DOUBLE_MINUS_SIGN);
        if (ObjectUtil.isNotEmpty(itemList)) {
            double avg = CommonConst.DIGIT_DOUBLE_0;
            for (ElectricPowerFactorItem li : itemList) {
                try {
                    if (!li.getValue().equals(CommonConst.DOUBLE_MINUS_SIGN)) {
                        avg += DoubleUtil.toDouble(li.getValue());
                    }
                } catch (Exception e) {
                    log.error(e.getMessage());
                }
            }
            detail.setAvg(DoubleUtil.formatDoubleToStr(avg / itemList.size()));
        }

        return vo;
    }

}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/service/impl/ElectricThreePhaseServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,413 @@
package com.zhitan.energyMonitor.service.impl;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.zhitan.basicdata.domain.MeterImplement;
import com.zhitan.basicdata.mapper.MeterImplementMapper;
import com.zhitan.common.constant.CommonConst;
import com.zhitan.common.constant.TimeTypeConst;
import com.zhitan.common.utils.*;
import com.zhitan.energyMonitor.domain.vo.ElectricThreePhaseDetail;
import com.zhitan.energyMonitor.domain.vo.ElectricThreePhaseItem;
import com.zhitan.energyMonitor.domain.vo.ElectricThreePhaseTempModel;
import com.zhitan.energyMonitor.domain.vo.ElectricThreePhaseVO;
import com.zhitan.energyMonitor.service.IElectricThreePhaseService;
import com.zhitan.model.domain.EnergyIndex;
import com.zhitan.realtimedata.domain.TagValue;
import com.zhitan.realtimedata.service.RealtimeDatabaseService;
import org.joda.time.DateTime;
import org.joda.time.Duration;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Description: sensor_alarm_item
 * @Author: jeecg-boot
 * @Date: 2022-04-19
 * @Version: V1.0
 */
@Service
public class ElectricThreePhaseServiceImpl implements IElectricThreePhaseService {

    @Autowired
    private RealtimeDatabaseService realtimeDatabaseService;
    @Resource
    private MeterImplementMapper meterImplementMapper;

    /**
     * èŽ·å–三相不平衡数据
     *
     * @param timeType        æ—¶é—´ç±»åž‹
     * @param timeCode        æ—¶é—´ç¼–码
     * @param energyIndexList ç‚¹ä½é›†åˆ
     * @param requestType     ç±»åž‹
     * @return ElectricThreePhaseVo
     * @Date 14:27 2022/5/30
     **/
    @Override
    public ElectricThreePhaseVO list(String timeType, String timeCode, List<EnergyIndex> energyIndexList, String requestType, String meterId) {
        ElectricThreePhaseVO vo = new ElectricThreePhaseVO();
        if (ObjectUtil.isEmpty(energyIndexList)) {
            return vo;
        }
        // èŽ·å–电压不平衡数据
        if (CommonConst.STR_NUMBER_0.equals(requestType)) {
            energyIndexList = energyIndexList.stream()
                    .filter(x -> StringUtil.ifEmptyOrNullReturnValue(x.getCode()).trim().endsWith(CommonConst.TAG_CODE_VOLTAGE_A)
                            || StringUtil.ifEmptyOrNullReturnValue(x.getCode()).trim().endsWith(CommonConst.TAG_CODE_VOLTAGE_B)
                            || StringUtil.ifEmptyOrNullReturnValue(x.getCode()).trim().endsWith(CommonConst.TAG_CODE_VOLTAGE_C)).collect(Collectors.toList());
        } else {
            energyIndexList = energyIndexList.stream()
                    .filter(x -> StringUtil.ifEmptyOrNullReturnValue(x.getCode()).trim().endsWith(CommonConst.TAG_CODE_CURRENT_A)
                            || StringUtil.ifEmptyOrNullReturnValue(x.getCode()).trim().endsWith(CommonConst.TAG_CODE_CURRENT_B)
                            || StringUtil.ifEmptyOrNullReturnValue(x.getCode()).trim().endsWith(CommonConst.TAG_CODE_CURRENT_C))
                    .collect(Collectors.toList());
        }
        List<String> tagCodeList = energyIndexList.stream().map(EnergyIndex::getCode).collect(Collectors.toList());
        tagCodeList.add(CommonConst.STR_NUMBER_MINUS_ONE);
        String tagCodes = String.join(StrUtil.COMMA, tagCodeList);

        Date start = ChartUtils.getDateTime(timeType, timeCode);
        Date end = getEndTime(timeType, start);

        DateTime begin = new DateTime(start);
        DateTime finish = new DateTime(end);
        long millis = new Duration(begin, finish).getMillis();
        int pointCount = IntegerUtil.toInt(millis / CommonConst.DIGIT_3600 / CommonConst.DIGIT_1000);

        List<TagValue> tagValueList = realtimeDatabaseService.retrieve(tagCodes, start, end, pointCount);
        List<ElectricThreePhaseItem> itemList = new ArrayList<>();
        List<Date> dateList = new ArrayList<>();
        ChartUtils.generateDateList(timeType, timeCode, dateList);
        ElectricThreePhaseTempModel tempModel = new ElectricThreePhaseTempModel();

        Date now = new Date();
        for (Date date : dateList) {
            Date tempDate = date;
            Date temNow = now;
            switch (timeType) {
                case TimeTypeConst.TIME_TYPE_DAY:
                    tempDate = DateTimeUtil.addHours(date, CommonConst.DIGIT_1);
                    //当前时间转成整时整点
                    temNow = DateTimeUtil.getHourTime(TimeTypeConst.TIME_TYPE_HOUR, now);
                    break;
                case TimeTypeConst.TIME_TYPE_MONTH:
                    tempDate = date;
                    //当前时间转成整时整点
                    temNow = DateTimeUtil.getHourTime(TimeTypeConst.TIME_TYPE_DAY, now);
                    break;
                case TimeTypeConst.TIME_TYPE_YEAR:
                    tempDate = date;
                    temNow = DateTimeUtil.getHourTime(TimeTypeConst.TIME_TYPE_MONTH, now);
                    break;
                default:
                    break;
            }
            MeterImplement meterImplement = meterImplementMapper.selectById(meterId);

            ElectricThreePhaseItem temp = new ElectricThreePhaseItem();
            if (ObjectUtil.isNotEmpty(meterImplement)) {
                temp.setName(meterImplement.getMeterName());
            }
            temp.setTimeCode(ChartUtils.getTimeCode(timeType, date));
            temp.setTimeCodeChart(ChartUtils.getTimeCodeChart(timeType, date));
            temp.setValueA(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setValueB(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setValueC(CommonConst.DOUBLE_MINUS_SIGN);
            itemList.add(temp);
            // å¦‚果大于当前时间默认--
            if (DateTimeUtil.compareDateDiff(date, temNow) > CommonConst.DIGIT_0) {
                continue;
            }
            switch (timeType) {
                case TimeTypeConst.TIME_TYPE_DAY:
                    // æž„造当天每个小时的数据
                    listDayData(tempDate, tagValueList, temp, tempModel);
                    break;
                case TimeTypeConst.TIME_TYPE_MONTH:
                    // æž„造当月每天的数据
                    listMonthData(tempDate, tagValueList, temp, tempModel);
                    break;
                case TimeTypeConst.TIME_TYPE_YEAR:
                    // æž„造当年每月的数据
                    listYearData(tempDate, tagValueList, temp, tempModel);
                    break;
                default:
                    break;
            }
        }

        if (ObjectUtil.isEmpty(tempModel.getMin()) || CommonConst.MIN_INIT_VALUE == tempModel.getMin()) {
            tempModel.setMin(null);
        }
        //设置值
        ElectricThreePhaseDetail detail = new ElectricThreePhaseDetail();
        BeanUtils.copyProperties(tempModel, detail);
        detail.setMax(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setMaxTime(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setValueMaxA(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setValueMaxB(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setValueMaxC(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setMin(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setMinTime(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setValueMinA(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setValueMinB(CommonConst.DOUBLE_MINUS_SIGN);
        detail.setValueMinC(CommonConst.DOUBLE_MINUS_SIGN);
        if (ObjectUtil.isNotNull(tempModel.getMax())) {
            detail.setMax(DoubleUtil.formatDoubleToStr(tempModel.getMax()) + CommonConst.SYMBOL_PERCENT);
            detail.setMaxTime(DateTimeUtil.getDateTime(tempModel.getMaxTime()));
            detail.setValueMaxA(DoubleUtil.formatDoubleToStr(tempModel.getValueMaxA()));
            detail.setValueMaxB(DoubleUtil.formatDoubleToStr(tempModel.getValueMaxB()));
            detail.setValueMaxC(DoubleUtil.formatDoubleToStr(tempModel.getValueMaxC()));
        }
        if (ObjectUtil.isNotNull(tempModel.getMin())) {
            detail.setMin(DoubleUtil.formatDoubleToStr(tempModel.getMin()) + CommonConst.SYMBOL_PERCENT);
            detail.setMinTime(DateTimeUtil.getDateTime(tempModel.getMinTime()));
            detail.setValueMinA(DoubleUtil.formatDoubleToStr(tempModel.getValueMinA()));
            detail.setValueMinB(DoubleUtil.formatDoubleToStr(tempModel.getValueMinB()));
            detail.setValueMinC(DoubleUtil.formatDoubleToStr(tempModel.getValueMinC()));
        }
        vo.setDetail(detail);
        vo.setItemList(itemList);
        return vo;
    }

    /**
     * æž„造当月的数据列表
     *
     * @param date
     * @param tagValueList
     * @param temp
     * @param tempModel
     */
    private void listYearData(Date date, List<TagValue> tagValueList, ElectricThreePhaseItem temp, ElectricThreePhaseTempModel tempModel) {
        List<Date> dateList = new ArrayList<>();
        ChartUtils.generateDateList(TimeTypeConst.TIME_TYPE_MONTH, DateTimeUtil.getDateTime(date, DateTimeUtil.COMMON_PATTERN_TO_MONTH), dateList);
        ElectricThreePhaseTempModel tempModelMonth = new ElectricThreePhaseTempModel();
        for (Date date1 : dateList) {
            listMonthData(date1, tagValueList, temp, tempModelMonth);
            temp.setMax(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setMin(CommonConst.DOUBLE_MINUS_SIGN);
            if (ObjectUtil.isNotNull(tempModelMonth.getMax())) {
                temp.setMax(DoubleUtil.formatDoubleToStr(tempModelMonth.getMax()));
            }
            if (ObjectUtil.isNotNull(tempModelMonth.getMin())) {
                temp.setMin(DoubleUtil.formatDoubleToStr(tempModelMonth.getMin()));
            }
            if (ObjectUtil.isEmpty(tempModel.getMin()) || CommonConst.MIN_INIT_VALUE == tempModel.getMin()) {
                tempModel.setMin(null);
            }
            if (ObjectUtil.isNotNull(tempModelMonth.getMax())) {
                if (ObjectUtil.isNull(tempModel.getMax()) || (ObjectUtil.isNotNull(tempModel.getMax()) && tempModelMonth.getMax() > tempModel.getMax())) {
                    tempModel.setMax(DoubleUtil.formatDouble(tempModelMonth.getMax()));
                    tempModel.setMaxTime(tempModelMonth.getMaxTime());
                    tempModel.setValueMaxA(DoubleUtil.formatDouble(tempModelMonth.getValueMaxA()));
                    tempModel.setValueMaxB(DoubleUtil.formatDouble(tempModelMonth.getValueMaxB()));
                    tempModel.setValueMaxC(DoubleUtil.formatDouble(tempModelMonth.getValueMaxC()));
                }
            }
            if (ObjectUtil.isNotNull(tempModelMonth.getMin())) {
                if (ObjectUtil.isNull(tempModel.getMin()) || (ObjectUtil.isNotNull(tempModel.getMin()) && tempModelMonth.getMin() <= tempModel.getMin())) {
                    tempModel.setMin(DoubleUtil.formatDouble(tempModelMonth.getMin()));
                    tempModel.setMinTime(tempModelMonth.getMinTime());
                    tempModel.setValueMinA(DoubleUtil.formatDouble(tempModelMonth.getValueMinA()));
                    tempModel.setValueMinB(DoubleUtil.formatDouble(tempModelMonth.getValueMinB()));
                    tempModel.setValueMinC(DoubleUtil.formatDouble(tempModelMonth.getValueMinC()));
                }
            }
        }
    }

    /**
     * æž„造当月的数据列表
     *
     * @param date
     * @param tagValueList
     * @param temp
     * @param tempModel
     */
    private void listMonthData(Date date, List<TagValue> tagValueList, ElectricThreePhaseItem temp, ElectricThreePhaseTempModel tempModel) {
        List<Date> dateList = new ArrayList<>();
        ChartUtils.generateDateList(TimeTypeConst.TIME_TYPE_DAY, DateTimeUtil.getDateTime(date, DateTimeUtil.COMMON_PATTERN_TO_DAY), dateList);
        ElectricThreePhaseTempModel tempModelDay = new ElectricThreePhaseTempModel();
        for (Date date1 : dateList) {
            Date tempDate = DateTimeUtil.addHours(date1, CommonConst.DIGIT_1);
            listDayData(tempDate, tagValueList, temp, tempModelDay);
            temp.setMax(CommonConst.DOUBLE_MINUS_SIGN);
            temp.setMin(CommonConst.DOUBLE_MINUS_SIGN);
            if (ObjectUtil.isNotNull(tempModelDay.getMax())) {
                temp.setMax(DoubleUtil.formatDoubleToStr(tempModelDay.getMax()));
            }
            if (ObjectUtil.isNotNull(tempModelDay.getMin())) {
                temp.setMin(DoubleUtil.formatDoubleToStr(tempModelDay.getMin()));
            }
            if (ObjectUtil.isEmpty(tempModel.getMin()) || CommonConst.MIN_INIT_VALUE == tempModel.getMin()) {
                tempModel.setMin(null);
            }
            if (ObjectUtil.isNotNull(tempModelDay.getMax())) {
                if (ObjectUtil.isNull(tempModel.getMax()) || (ObjectUtil.isNotNull(tempModel.getMax()) && tempModelDay.getMax() > tempModel.getMax())) {
                    tempModel.setMax(DoubleUtil.formatDouble(tempModelDay.getMax()));
                    tempModel.setMaxTime(tempModelDay.getMaxTime());
                    tempModel.setValueMaxA(DoubleUtil.formatDouble(tempModelDay.getValueMaxA()));
                    tempModel.setValueMaxB(DoubleUtil.formatDouble(tempModelDay.getValueMaxB()));
                    tempModel.setValueMaxC(DoubleUtil.formatDouble(tempModelDay.getValueMaxC()));
                }
            }
            if (ObjectUtil.isNotNull(tempModelDay.getMin())) {
                if (ObjectUtil.isNull(tempModel.getMin()) || (ObjectUtil.isNotNull(tempModel.getMin()) && tempModelDay.getMin() <= tempModel.getMin())) {
                    tempModel.setMin(DoubleUtil.formatDouble(tempModelDay.getMin()));
                    tempModel.setMinTime(tempModelDay.getMinTime());
                    tempModel.setValueMinA(DoubleUtil.formatDouble(tempModelDay.getValueMinA()));
                    tempModel.setValueMinB(DoubleUtil.formatDouble(tempModelDay.getValueMinB()));
                    tempModel.setValueMinC(DoubleUtil.formatDouble(tempModelDay.getValueMinC()));
                }
            }
        }
    }

    /**
     * èŽ·å–当天的数据列表
     *
     * @param date
     * @param tagValueList
     * @param tempModel
     */
    private void listDayData(Date date, List<TagValue> tagValueList, ElectricThreePhaseItem temp, ElectricThreePhaseTempModel tempModel) {
        Date endTime = DateTimeUtil.addHours(date, CommonConst.DIGIT_1);
        List<TagValue> currentTagValueList = tagValueList.stream().filter(x -> DateTimeUtil.compareDateDiff(date, x.getDataTime()) <= 0 && DateTimeUtil.compareDateDiff(endTime, x.getDataTime()) > 0).collect(Collectors.toList());
        List<TagValue> currentATagValueList = currentTagValueList.stream().filter(x -> StringUtil.ifEmptyOrNullReturnValue(x.getTagCode()).trim().endsWith("_A")).collect(Collectors.toList());
        List<TagValue> currentBTagValueList = currentTagValueList.stream().filter(x -> StringUtil.ifEmptyOrNullReturnValue(x.getTagCode()).trim().endsWith("_B")).collect(Collectors.toList());
        List<TagValue> currentCTagValueList = currentTagValueList.stream().filter(x -> StringUtil.ifEmptyOrNullReturnValue(x.getTagCode()).trim().endsWith("_C")).collect(Collectors.toList());
        TagValue tagValueA = currentATagValueList.stream().filter(x -> DateTimeUtil.compareDateDiff(date, x.getDataTime()) == 0).findAny().orElse(null);
        TagValue tagValueB = currentBTagValueList.stream().filter(x -> DateTimeUtil.compareDateDiff(date, x.getDataTime()) == 0).findAny().orElse(null);
        TagValue tagValueC = currentCTagValueList.stream().filter(x -> DateTimeUtil.compareDateDiff(date, x.getDataTime()) == 0).findAny().orElse(null);
        Double valueA = null, valueB = null, valueC = null;
        if (ObjectUtil.isNotEmpty(tagValueA)) {
            valueA = tagValueA.getValue();
            temp.setValueA(String.valueOf(DoubleUtil.formatDouble(tagValueA.getValue())));
        } else {
            temp.setValueA(CommonConst.DOUBLE_MINUS_SIGN);
        }
        if (!ObjectUtil.isEmpty(tagValueB)) {
            valueB = tagValueB.getValue();
            temp.setValueB(String.valueOf(DoubleUtil.formatDouble(tagValueB.getValue())));
        } else {
            temp.setValueB(CommonConst.DOUBLE_MINUS_SIGN);
        }
        if (!ObjectUtil.isEmpty(tagValueC)) {
            valueC = tagValueC.getValue();
            temp.setValueC(String.valueOf(DoubleUtil.formatDouble(tagValueC.getValue())));
        } else {
            temp.setValueC(CommonConst.DOUBLE_MINUS_SIGN);
        }
        Double value = calcUnbalanceValue(valueA, valueB, valueC);
        if (ObjectUtil.isEmpty(value)) {
            return;
        }
        if (ObjectUtil.isEmpty(tempModel.getMin()) || CommonConst.MIN_INIT_VALUE == tempModel.getMin()) {
            tempModel.setMin(value);
        }
        if (ObjectUtil.isEmpty(tempModel.getMax()) || value > tempModel.getMax()) {
            tempModel.setMax(DoubleUtil.formatDouble(value));
            if (!ObjectUtil.isEmpty(tagValueA)) {
                tempModel.setMaxTime(tagValueA.getDataTime());
            }
            tempModel.setValueMaxA(DoubleUtil.formatDouble(valueA));
            tempModel.setValueMaxB(DoubleUtil.formatDouble(valueB));
            tempModel.setValueMaxC(DoubleUtil.formatDouble(valueC));
        }
        if (ObjectUtil.isEmpty(tempModel.getMin()) || value <= tempModel.getMin()) {
            tempModel.setMin(DoubleUtil.formatDouble(value));
            tempModel.setValueMinA(DoubleUtil.formatDouble(valueA));
            tempModel.setValueMinB(DoubleUtil.formatDouble(valueB));
            tempModel.setValueMinC(DoubleUtil.formatDouble(valueC));
            if (!ObjectUtil.isEmpty(tagValueA)) {
                tempModel.setMinTime(tagValueA.getDataTime());
            }
        }
    }

    /**
     * è®¡ç®—三相不平衡极值
     *
     * @param valueA
     * @param valueB
     * @param valueC
     * @return
     */
    private Double calcUnbalanceValue(Double valueA, Double valueB, Double valueC) {
        /**
         * 1、计算三相平均电流，A/B/C三相电流相加除以3
         * 2、 MAX（相电流-三相平均电流）/三相平均电流；
         * æ¯”如三相电流分别为IA=9A IB=8A IC=4A，则三相平均电流为7A，相电流-三相平均电流分别为2A 1A 3A，取差值最大那个，故MAX（相电流-三相平均电流）=3A，所以三相电流不平衡度=3/7。
         */
        Double result = null;
        Double sum = null;
        if (ObjectUtil.isNotNull(valueA)) {
            sum = valueA;
        }
        if (ObjectUtil.isNotNull(valueB)) {
            sum += valueB;
        }
        if (ObjectUtil.isNotNull(valueC)) {
            sum += valueC;
        }
        if (ObjectUtil.isNotNull(sum)) {
            double avg = sum / CommonConst.DIGIT_3;
            double diff1 = 0, diff2 = 0, diff3 = 0;
            if (ObjectUtil.isNotNull(valueA)) {
                diff1 = Math.abs(valueA - avg);
            }
            if (ObjectUtil.isNotNull(valueB)) {
                diff2 = Math.abs(valueB - avg);
            }
            if (ObjectUtil.isNotNull(valueC)) {
                diff3 = Math.abs(valueC - avg);
            }
            double max = diff1;
            if (diff2 > max) {
                max = diff2;
            }
            if (diff3 > max) {
                max = diff3;
            }
            if (avg != CommonConst.DIGIT_DOUBLE_0) {
                result = max * CommonConst.DIGIT_DOUBLE_100 / avg;
            }
        }

        return result;
    }

    /**
     * èŽ·å–对应的结束时间
     *
     * @param timeType
     * @param date
     * @return
     */
    public static Date getEndTime(String timeType, Date date) {
        Date d1 = null;
        switch (timeType) {
            case TimeTypeConst.TIME_TYPE_DAY:
                d1 = DateTimeUtil.addDays(date, CommonConst.DIGIT_1);
                break;
            case TimeTypeConst.TIME_TYPE_MONTH:
                d1 = DateTimeUtil.addMonths(date, CommonConst.DIGIT_1);
                break;
            case TimeTypeConst.TIME_TYPE_YEAR:
                d1 = DateTimeUtil.addYears(date, CommonConst.DIGIT_1);
                break;
            default:
                break;
        }
        return d1;
    }
}

 zhitan-system/src/main/java/com/zhitan/energyMonitor/service/impl/EnergyUnitToDeviceServiceImpl.java

ÎļþÒÑɾ³ý

 zhitan-system/src/main/java/com/zhitan/model/domain/EnergyIndex.java

@@ -75,18 +75,21 @@

  @ApiModelProperty(value = "表计id")
  private String meterId;

  @ApiModelProperty(value = "顺序号")
  @Excel(name = "顺序号")
  private int orderNum;

  @ApiModelProperty(value = "")
  private String equipment;

  @ApiModelProperty(value = "id")
  private String energyId;

  @Transient
  @TableField(exist = false)
  private  String meterName;

  public void setIndexId(String indexId) {
    this.indexId = indexId;
  }

 zhitan-system/src/main/java/com/zhitan/model/domain/NodeIndex.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,26 @@
package com.zhitan.model.domain;

import lombok.Data;

import java.io.Serializable;

/**
 * æ¨¡åž‹èŠ‚点与指标的关联关系(NodeIndex)实体类
 *
 * @author makejava
 * @since 2025-02-10 15:08:14
 */
@Data
public class NodeIndex implements Serializable {
    private static final long serialVersionUID = 386292923712960012L;
    /**
     * èŠ‚点主键
     */
    private String nodeId;
    /**
     * æŒ‡æ ‡ä¸»é”®
     */
    private String indexId;

}


 zhitan-system/src/main/java/com/zhitan/model/mapper/ModelNodeMapper.java

@@ -5,11 +5,14 @@
import com.zhitan.basicdata.domain.MeterImplement;
import com.zhitan.basicdata.domain.SysEnergy;
import com.zhitan.basicdata.domain.SysProduct;
import com.zhitan.common.enums.TimeType;
import com.zhitan.dataitem.domain.vo.NodeIndexValueVO;
import com.zhitan.model.domain.EnergyIndex;
import com.zhitan.model.domain.ModelNode;
import com.zhitan.model.domain.vo.ModelNodeIndexInfor;
import org.apache.ibatis.annotations.Param;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;

@@ -196,4 +199,20 @@
    ModelNode getFirstModeNodeInfo(String modelCode);

    List<ModelNodeIndexInfor> selectIndexByNodeIds(@Param("modelCode") String modelCode,@Param("nodeIds") List<String> nodeIds);

    /**
     * æ ¹æ®çˆ¶èŠ‚点id和能源类型查询点位下的累积量
     */
    List<NodeIndexValueVO> getDataItemByParentNodeId(@Param("parentId") String parentId,
                                                     @Param("energyType") String energyType,
                                                     @Param("timeType") TimeType timeType,
                                                     @Param("dateTimeMap") Map<String, LocalDateTime> dateTimeMap);

    /**
     * æ ¹æ®èŠ‚点id和能源类型查询点位下的累积量
     */
    List<NodeIndexValueVO> getDataItemByNodeId(@Param("nodeId") String nodeId,
                                                     @Param("energyType") String energyType,
                                                     @Param("timeType") TimeType timeType,
                                                     @Param("dateTimeMap") Map<String, LocalDateTime> dateTimeMap);
}

 zhitan-system/src/main/java/com/zhitan/model/mapper/NodeIndexMapper.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,15 @@
package com.zhitan.model.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.zhitan.model.domain.NodeIndex;

/**
 * æ¨¡åž‹èŠ‚点与指标的关联关系(NodeIndex)表数据库访问层
 *
 * @author makejava
 * @since 2025-02-10 15:09:17
 */
public interface NodeIndexMapper extends BaseMapper<NodeIndex> {

}


 zhitan-system/src/main/java/com/zhitan/model/service/IEnergyIndexService.java

@@ -13,107 +13,125 @@
 * @author fanxinfu
 * @date 2020-02-14
 */
public interface IEnergyIndexService  {
public interface IEnergyIndexService {

  EnergyIndex getiEnergyIndexByCode(String code);
    EnergyIndex getiEnergyIndexByCode(String code);

  /**
   * æ ¹æ®è®¡é‡å™¨å…·id集合查询点位信息
   *
   * @param meterId è®¡é‡å™¨å…·id集合
   * @return
   */
  List<EnergyIndex> listIndexByMeterIds(String nodeId,List<String> meterId);
    /**
     * æ ¹æ®è®¡é‡å™¨å…·id集合查询点位信息
     *
     * @param meterId è®¡é‡å™¨å…·id集合
     * @return
     */
    List<EnergyIndex> listIndexByMeterIds(String nodeId, List<String> meterId);

  /**
   * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯
   *
   * @param indexId æŒ‡æ ‡ä¿¡æ¯ID
   * @return æŒ‡æ ‡ä¿¡æ¯
   */
  EnergyIndex selectEnergyIndexById(String indexId);
    /**
     * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯
     *
     * @param indexId æŒ‡æ ‡ä¿¡æ¯ID
     * @return æŒ‡æ ‡ä¿¡æ¯
     */
    EnergyIndex selectEnergyIndexById(String indexId);

  /**
   * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯
   *
   * @param indexId æŒ‡æ ‡ä¿¡æ¯ID
   * @return æŒ‡æ ‡ä¿¡æ¯
   */
  List<EnergyIndex> selectEnergyIndexByIds(List<String> indexId);
    /**
     * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯
     *
     * @param indexId æŒ‡æ ‡ä¿¡æ¯ID
     * @return æŒ‡æ ‡ä¿¡æ¯
     */
    List<EnergyIndex> selectEnergyIndexByIds(List<String> indexId);

  /**
   * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯åˆ—表
   *
   * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
   * @return æŒ‡æ ‡ä¿¡æ¯é›†åˆ
   */
  List<EnergyIndex> selectEnergyIndexList(EnergyIndex energyIndex);
    /**
     * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯åˆ—表
     *
     * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
     * @return æŒ‡æ ‡ä¿¡æ¯é›†åˆ
     */
    List<EnergyIndex> selectEnergyIndexList(EnergyIndex energyIndex);

  /**
   * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯åˆ—表
   *
   * @param query æŒ‡æ ‡ä¿¡æ¯
   * @return æŒ‡æ ‡ä¿¡æ¯é›†åˆ
   */
  List<EnergyIndex> selectEnergyIndexList(EnergyIndexQuery query);
    /**
     * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯åˆ—表
     *
     * @param query æŒ‡æ ‡ä¿¡æ¯
     * @return æŒ‡æ ‡ä¿¡æ¯é›†åˆ
     */
    List<EnergyIndex> selectEnergyIndexList(EnergyIndexQuery query);

  /**
   * æ–°å¢žæŒ‡æ ‡ä¿¡æ¯
   *
   * @param nodeId
   * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
   * @return ç»“æžœ
   */
  int insertEnergyIndex(String nodeId, EnergyIndex energyIndex);
    /**
     * æ–°å¢žæŒ‡æ ‡ä¿¡æ¯
     *
     * @param nodeId
     * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
     * @return ç»“æžœ
     */
    int insertEnergyIndex(String nodeId, EnergyIndex energyIndex);

  /**
   * ä¿®æ”¹æŒ‡æ ‡ä¿¡æ¯
   *
   * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
   * @return ç»“æžœ
   */
  int updateEnergyIndex(EnergyIndex energyIndex);
    /**
     * ä¿®æ”¹æŒ‡æ ‡ä¿¡æ¯
     *
     * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
     * @return ç»“æžœ
     */
    int updateEnergyIndex(EnergyIndex energyIndex);

  /**
   * æ‰¹é‡åˆ é™¤æŒ‡æ ‡ä¿¡æ¯
   *
   *
   * @param nodeId
   * @param indexIds éœ€è¦åˆ é™¤çš„指标信息ID
   * @return ç»“æžœ
   */
  int deleteEnergyIndexByIds(String nodeId, String[] indexIds);
    /**
     * æ‰¹é‡åˆ é™¤æŒ‡æ ‡ä¿¡æ¯
     *
     * @param nodeId
     * @param indexIds éœ€è¦åˆ é™¤çš„指标信息ID
     * @return ç»“æžœ
     */
    int deleteEnergyIndexByIds(String nodeId, String[] indexIds);

  boolean energyIndexHasExist(String code);
    boolean energyIndexHasExist(String code);

  boolean energyIndexHasExist(String indexId, String code);
    boolean energyIndexHasExist(String indexId, String code);

  AjaxResult addMeterIndex(String meterId);
    AjaxResult addMeterIndex(String meterId);

  List<EnergyIndex> getMeterIndex(String meterId);
    List<EnergyIndex> getMeterIndex(String meterId);

  boolean modelHasConfig(String modelCode);
    boolean modelHasConfig(String modelCode);

  List<EnergyIndex> selectCollectIndex(String deviceId);
    List<EnergyIndex> selectCollectIndex(String deviceId);

  List<EnergyIndex> getEnergyIndexByIds(List<String> indexIds);
    List<EnergyIndex> getEnergyIndexByIds(List<String> indexIds);

  List<EnergyIndex> getEnergyIndexByCodes(List<String> indexCodes);
    List<EnergyIndex> getEnergyIndexByCodes(List<String> indexCodes);

  List<EnergyIndex> getIndexByNodeAndChildrenNode(String nodeId);
    List<EnergyIndex> getIndexByNodeAndChildrenNode(String nodeId);

  List<EnergyIndex> searchIndexByNodeAndChildrenNode(String nodeId, String filter);
    List<EnergyIndex> searchIndexByNodeAndChildrenNode(String nodeId, String filter);

  void removeNodeIndex(String nodeId, List<String> removeLink);
    void removeNodeIndex(String nodeId, List<String> removeLink);

  AjaxResult importEnergyIndex(List<EnergyIndex> energyIndexList, boolean updateSupport);
    AjaxResult importEnergyIndex(List<EnergyIndex> energyIndexList, boolean updateSupport);

  List<EnergyIndex> getEnergyIndexMeterByCodes(List<String> indexCodes);
    List<EnergyIndex> getEnergyIndexMeterByCodes(List<String> indexCodes);

  Page<EnergyIndex> selectEnergyIndexPage(EnergyIndexQuery query, Long pageNum, Long pageSize);
    Page<EnergyIndex> selectEnergyIndexPage(EnergyIndexQuery query, Long pageNum, Long pageSize);

  Page<EnergyIndex> getMeterIndexList(List<String> meterIndexIds,String code,
                                      String name,Long pageNum, Long pageSize);
    Page<EnergyIndex> getMeterIndexList(List<String> meterIndexIds, String code,
                                        String name, Long pageNum, Long pageSize);

  List<EnergyIndex> getIndexByCode(String code,String nodeId);
    List<EnergyIndex> getIndexByCode(String code, String nodeId);

    /**
     * æ ¹æ®ç”¨èƒ½å•å…ƒid和设备id，以及点位编码获取点位
     *
     * @param nodeId    èŠ‚点id
     * @param meterId   è®¾å¤‡id
     * @param indexCode ç‚¹ä½ç¼–码或者点位编码的一部分
     * @return
     */
    EnergyIndex getDeviceIndexByCode(String nodeId, String meterId, String indexCode);

    /**
     * æ ¹æ®ç”¨èƒ½å•å…ƒid和设备id，以及点位编码获取点位
     *
     * @param nodeId  èŠ‚点id
     * @param meterId è®¾å¤‡id
     * @return
     */
    List<EnergyIndex> listDeviceIndex(String nodeId, String meterId);
}

 zhitan-system/src/main/java/com/zhitan/model/service/impl/EnergyIndexServiceImpl.java

@@ -1,6 +1,7 @@
package com.zhitan.model.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.zhitan.basicdata.domain.MeterImplement;
import com.zhitan.basicdata.services.IMeterImplementService;
@@ -17,6 +18,7 @@
import com.zhitan.model.service.IEnergyIndexService;
import com.zhitan.model.service.IModelNodeService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@@ -33,286 +35,333 @@
@Service
public class EnergyIndexServiceImpl implements IEnergyIndexService {

  @Autowired
  private EnergyIndexMapper energyIndexMapper;
  @Autowired
  private IDaqTemplateService daqTemplateService;
  @Autowired
  private IMeterImplementService meterImplementService;
  @Autowired
  private IModelNodeService modelNodeService;
    @Autowired
    private EnergyIndexMapper energyIndexMapper;
    @Autowired
    private IDaqTemplateService daqTemplateService;
    @Autowired
    private IMeterImplementService meterImplementService;
    @Autowired
    private IModelNodeService modelNodeService;

  @Autowired
  private ModelNodeMapper modelNodeMapper;
    @Autowired
    private ModelNodeMapper modelNodeMapper;

  @Override
  public EnergyIndex getiEnergyIndexByCode(String code) {
    return energyIndexMapper.getiEnergyIndexByCode(code);
  }

  @Override
  public List<EnergyIndex> listIndexByMeterIds(String nodeId, List<String> meterId) {
    return energyIndexMapper.listIndexByMeterIds(nodeId,meterId);
  }

  /**
   * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯
   *
   * @param indexId æŒ‡æ ‡ä¿¡æ¯ID
   * @return æŒ‡æ ‡ä¿¡æ¯
   */
  @Override
  public EnergyIndex selectEnergyIndexById(String indexId) {
    return energyIndexMapper.selectEnergyIndexById(indexId);
  }

  @Override
  public List<EnergyIndex> selectEnergyIndexByIds(List<String> indexId) {
    if (CollectionUtils.isEmpty(indexId)) {
      return Collections.emptyList();
    }
    return energyIndexMapper.selectEnergyIndexByIds(indexId);
  }

  @Override
  public List<EnergyIndex> selectEnergyIndexList(EnergyIndex energyIndex) {
    return energyIndexMapper.selectEnergyIndexList(energyIndex);
  }

  /**
   * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯åˆ—表
   *
   * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
   * @return æŒ‡æ ‡ä¿¡æ¯
   */
  @Override
  public List<EnergyIndex> selectEnergyIndexList(EnergyIndexQuery query) {
    return energyIndexMapper.selectEnergyIndex(query);
  }

  /**
   * æ–°å¢žæŒ‡æ ‡ä¿¡æ¯
   *
   * @param nodeId
   * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
   * @return ç»“æžœ
   */
  @Override
  public int insertEnergyIndex(String nodeId, EnergyIndex energyIndex) {
    energyIndex.setNodeId(nodeId);
    energyIndexMapper.insertEnergyIndex( energyIndex);
    return energyIndexMapper.insertNodeIndex(nodeId,energyIndex.getIndexId());
  }

  /**
   * ä¿®æ”¹æŒ‡æ ‡ä¿¡æ¯
   *
   * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
   * @return ç»“æžœ
   */
  @Override
  public int updateEnergyIndex(EnergyIndex energyIndex) {
    return energyIndexMapper.updateEnergyIndex(energyIndex);
  }

  /**
   * æ‰¹é‡åˆ é™¤æŒ‡æ ‡ä¿¡æ¯
   *
   * @param nodeId
   * @param indexIds éœ€è¦åˆ é™¤çš„指标信息ID
   * @return ç»“æžœ
   */
  @Override
  public int deleteEnergyIndexByIds(String nodeId, String[] indexIds) {
    return energyIndexMapper.deleteEnergyIndexByIds(nodeId, indexIds);
  }

  @Override
  public boolean energyIndexHasExist(String code) {
    int count = energyIndexMapper.energyIndexHasExist(code);
    return count > 0;
  }

  @Override
  public boolean energyIndexHasExist(String indexId, String code) {
    int count = energyIndexMapper.energyIndexHasExistWhenUpdate(indexId, code);
    return count > 0;
  }

  @Override
  public AjaxResult addMeterIndex(String meterId) {
    MeterImplement meterImplement = meterImplementService.selectMeterImplementById(meterId);
    if (meterImplement == null) {
      return AjaxResult.error("找不到对应的计量器具！");
    @Override
    public EnergyIndex getiEnergyIndexByCode(String code) {
        return energyIndexMapper.getiEnergyIndexByCode(code);
    }

    DaqTemplate query = new DaqTemplate();
    query.setDeviceType(meterImplement.getMeterType());
    List<DaqTemplate> daqTemplates = daqTemplateService.selectDaqTemplateList(query);
    if (daqTemplates.isEmpty()) {
      return AjaxResult.error("计量器具所属的类型没有找到对应的模板！");
    @Override
    public List<EnergyIndex> listIndexByMeterIds(String nodeId, List<String> meterId) {
        return energyIndexMapper.listIndexByMeterIds(nodeId, meterId);
    }

    List<EnergyIndex> energyIndices = new ArrayList<>();
    daqTemplates.forEach(daqTemplate -> {
      EnergyIndex energyIndex = new EnergyIndex();
      energyIndex.setIndexId(UUID.randomUUID().toString());
      energyIndex.setCode(meterImplement.getCode() + "_" + daqTemplate.getCode());
      energyIndex.setName(daqTemplate.getName());
      energyIndex.setUnitId(daqTemplate.getUnit());
      energyIndex.setIndexType(IndexType.COLLECT);
      energyIndex.setMeterId(meterId);
      energyIndices.add(energyIndex);
    });

    energyIndexMapper.deleteIndexByMeterId(meterId);
    energyIndexMapper.insertEnergyIndices(energyIndices);
    return AjaxResult.success();
  }

  @Override
  public List<EnergyIndex> getMeterIndex(String meterId) {
    return energyIndexMapper.getMeterIndex(meterId);
  }

  @Override
  public boolean modelHasConfig(String modelCode) {
    int count = energyIndexMapper.modelHasConfig(modelCode);
    return count > 0;
  }

  @Override
  public List<EnergyIndex> selectCollectIndex(String deviceId) {
    return energyIndexMapper.selectCollectIndex(deviceId);
  }

  @Override
  public List<EnergyIndex> getEnergyIndexByIds(List<String> indexIds) {
    return energyIndexMapper.getEnergyIndexByIds(indexIds);
  }

  @Override
  public List<EnergyIndex> getEnergyIndexByCodes(List<String> indexCodes) {
    if (indexCodes.isEmpty()) {
      return new ArrayList<>();
    /**
     * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯
     *
     * @param indexId æŒ‡æ ‡ä¿¡æ¯ID
     * @return æŒ‡æ ‡ä¿¡æ¯
     */
    @Override
    public EnergyIndex selectEnergyIndexById(String indexId) {
        return energyIndexMapper.selectEnergyIndexById(indexId);
    }

    return energyIndexMapper.getEnergyIndexByCodes(indexCodes);
  }

  @Override
  public List<EnergyIndex> getIndexByNodeAndChildrenNode(String nodeId) {
    return energyIndexMapper.getIndexByNodeAndChildrenNode(nodeId);
  }

  @Override
  public List<EnergyIndex> searchIndexByNodeAndChildrenNode(String nodeId, String filter) {
    return energyIndexMapper.searchIndexByNodeAndChildrenNode(nodeId, filter);
  }

  @Override
  public void removeNodeIndex(String nodeId, List<String> removeLink) {
    energyIndexMapper.removeNodeIndex(nodeId, removeLink);
  }

  @Override
  public AjaxResult importEnergyIndex(List<EnergyIndex> energyIndexList, boolean updateSupport) {
    List<String> codes = energyIndexList.stream().map(EnergyIndex::getCode)
        .collect(Collectors.toList());
    List<String> nodeCodes = energyIndexList.stream().map(EnergyIndex::getNodeId)
        .collect(Collectors.toList());
    List<EnergyIndex> indexList = energyIndexMapper.getEnergyIndexByCodes(codes);
    List<ModelNode> modelNodes = modelNodeService.getModelNodeByNodeCodes(nodeCodes);
    Map<String, String> nodeCodeToId = modelNodes.stream()
        .collect(Collectors.toMap(ModelNode::getCode, ModelNode::getNodeId));
    Set<String> cacheIndexCodes = indexList.stream().map(EnergyIndex::getCode)
        .collect(Collectors.toSet());

    List<EnergyIndex> insertData = new ArrayList<>();
    List<EnergyIndex> updateData = new ArrayList<>();
    List<String> errorNodeCode = new ArrayList<>();
    List<String> insertIndexCode = new ArrayList<>();
    AtomicBoolean existDuplicateCode = new AtomicBoolean(false);
    energyIndexList.forEach(energyIndex -> {
      if (cacheIndexCodes.contains(energyIndex.getCode())) {
        updateData.add(energyIndex);
      } else {
        String nodeCode = energyIndex.getNodeId();
        if (nodeCodeToId.containsKey(nodeCode)) {
          if (!insertIndexCode.contains(energyIndex.getCode())) {
            insertIndexCode.add(energyIndex.getCode());
            energyIndex.setIndexId(UUID.randomUUID().toString());
            energyIndex.setNodeId(nodeCodeToId.get(nodeCode));
            insertData.add(energyIndex);
          } else {
            existDuplicateCode.set(true);
          }
        } else if (!errorNodeCode.contains(nodeCode)) {
          errorNodeCode.add(nodeCode);
    @Override
    public List<EnergyIndex> selectEnergyIndexByIds(List<String> indexId) {
        if (CollectionUtils.isEmpty(indexId)) {
            return Collections.emptyList();
        }
      }
    });

    if (updateSupport && !updateData.isEmpty()) {
      updateData.forEach(energyIndexMapper::updateEnergyIndex);
        return energyIndexMapper.selectEnergyIndexByIds(indexId);
    }

    if (!insertData.isEmpty()) {
      energyIndexMapper.saveEnergyIndex(insertData);
    @Override
    public List<EnergyIndex> selectEnergyIndexList(EnergyIndex energyIndex) {
        return energyIndexMapper.selectEnergyIndexList(energyIndex);
    }

    String errMsg = "";
    if (existDuplicateCode.get()) {
      errMsg += "存在重复的指标编码，已自动过滤！";
    /**
     * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯åˆ—表
     *
     * @return æŒ‡æ ‡ä¿¡æ¯
     */
    @Override
    public List<EnergyIndex> selectEnergyIndexList(EnergyIndexQuery query) {
        return energyIndexMapper.selectEnergyIndex(query);
    }

    if (!errorNodeCode.isEmpty()) {
      errMsg += String.join(",", errorNodeCode) + "没有找到对应的节点数据，因此其下的所有指标导入失败！";
    /**
     * æ–°å¢žæŒ‡æ ‡ä¿¡æ¯
     *
     * @param nodeId
     * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
     * @return ç»“æžœ
     */
    @Override
    public int insertEnergyIndex(String nodeId, EnergyIndex energyIndex) {
        energyIndex.setNodeId(nodeId);
        energyIndexMapper.insertEnergyIndex(energyIndex);
        return energyIndexMapper.insertNodeIndex(nodeId, energyIndex.getIndexId());
    }

    if (StringUtils.isNotBlank(errMsg)) {
      return AjaxResult.error(errMsg);
    }
    return AjaxResult.success("导入成功！");
  }

  @Override
  public List<EnergyIndex> getEnergyIndexMeterByCodes(List<String> indexCodes) {
    if (indexCodes.isEmpty()) {
      return new ArrayList<>();
    /**
     * ä¿®æ”¹æŒ‡æ ‡ä¿¡æ¯
     *
     * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
     * @return ç»“æžœ
     */
    @Override
    public int updateEnergyIndex(EnergyIndex energyIndex) {
        return energyIndexMapper.updateEnergyIndex(energyIndex);
    }

    return energyIndexMapper.getEnergyIndexMeterByCodes(indexCodes);
  }
    /**
     * æ‰¹é‡åˆ é™¤æŒ‡æ ‡ä¿¡æ¯
     *
     * @param nodeId
     * @param indexIds éœ€è¦åˆ é™¤çš„指标信息ID
     * @return ç»“æžœ
     */
    @Override
    public int deleteEnergyIndexByIds(String nodeId, String[] indexIds) {
        return energyIndexMapper.deleteEnergyIndexByIds(nodeId, indexIds);
    }

  /**
   * @description: hmj åˆ†é¡µæŸ¥è¯¢
   * @param query
   * @param pageNum
   * @param pageSize
   * @return com.baomidou.mybatisplus.extension.plugins.pagination.Page<com.zhitan.model.domain.EnergyIndex>
   * @author: hmj
   * @date: 2024/10/11 23:56
   */
  @Override
  public Page<EnergyIndex> selectEnergyIndexPage(EnergyIndexQuery query, Long pageNum, Long pageSize) {
    return  energyIndexMapper.selectEnergyIndexPage(new Page<>(pageNum,pageSize),query);
  }
    @Override
    public boolean energyIndexHasExist(String code) {
        int count = energyIndexMapper.energyIndexHasExist(code);
        return count > 0;
    }

  @Override
  public Page<EnergyIndex> getMeterIndexList(List<String> meterIndexIds,String code,
                                             String name,Long pageNum, Long pageSize) {
    LambdaQueryWrapper<EnergyIndex> queryWrapper = new LambdaQueryWrapper<>();
    queryWrapper.in(EnergyIndex::getMeterId,meterIndexIds);
    queryWrapper.like(StringUtils.isNotEmpty(code),EnergyIndex::getCode,code);
    queryWrapper.like(StringUtils.isNotEmpty(name),EnergyIndex::getName,name);
    return energyIndexMapper.selectPage(new Page<>(pageNum,pageSize),queryWrapper);
  }
    @Override
    public boolean energyIndexHasExist(String indexId, String code) {
        int count = energyIndexMapper.energyIndexHasExistWhenUpdate(indexId, code);
        return count > 0;
    }

  @Override
  public List<EnergyIndex> getIndexByCode(String code, String nodeId) {
    List<EnergyIndex> energyIndexList =  energyIndexMapper.getIndexByCode(code,nodeId);
    @Override
    public AjaxResult addMeterIndex(String meterId) {
        MeterImplement meterImplement = meterImplementService.selectMeterImplementById(meterId);
        if (meterImplement == null) {
            return AjaxResult.error("找不到对应的计量器具！");
        }

    return energyIndexList;
  }
        DaqTemplate query = new DaqTemplate();
        query.setDeviceType(meterImplement.getMeterType());
        List<DaqTemplate> daqTemplates = daqTemplateService.selectDaqTemplateList(query);
        if (daqTemplates.isEmpty()) {
            return AjaxResult.error("计量器具所属的类型没有找到对应的模板！");
        }

        List<EnergyIndex> energyIndices = new ArrayList<>();
        daqTemplates.forEach(daqTemplate -> {
            EnergyIndex energyIndex = new EnergyIndex();
            energyIndex.setIndexId(UUID.randomUUID().toString());
            energyIndex.setCode(meterImplement.getCode() + "_" + daqTemplate.getCode());
            energyIndex.setName(daqTemplate.getName());
            energyIndex.setUnitId(daqTemplate.getUnit());
            energyIndex.setIndexType(IndexType.COLLECT);
            energyIndex.setMeterId(meterId);
            energyIndices.add(energyIndex);
        });

        energyIndexMapper.deleteIndexByMeterId(meterId);
        energyIndexMapper.insertEnergyIndices(energyIndices);
        return AjaxResult.success();
    }

    @Override
    public List<EnergyIndex> getMeterIndex(String meterId) {
        return energyIndexMapper.getMeterIndex(meterId);
    }

    @Override
    public boolean modelHasConfig(String modelCode) {
        int count = energyIndexMapper.modelHasConfig(modelCode);
        return count > 0;
    }

    @Override
    public List<EnergyIndex> selectCollectIndex(String deviceId) {
        return energyIndexMapper.selectCollectIndex(deviceId);
    }

    @Override
    public List<EnergyIndex> getEnergyIndexByIds(List<String> indexIds) {
        return energyIndexMapper.getEnergyIndexByIds(indexIds);
    }

    @Override
    public List<EnergyIndex> getEnergyIndexByCodes(List<String> indexCodes) {
        if (indexCodes.isEmpty()) {
            return new ArrayList<>();
        }

        return energyIndexMapper.getEnergyIndexByCodes(indexCodes);
    }

    @Override
    public List<EnergyIndex> getIndexByNodeAndChildrenNode(String nodeId) {
        return energyIndexMapper.getIndexByNodeAndChildrenNode(nodeId);
    }

    @Override
    public List<EnergyIndex> searchIndexByNodeAndChildrenNode(String nodeId, String filter) {
        return energyIndexMapper.searchIndexByNodeAndChildrenNode(nodeId, filter);
    }

    @Override
    public void removeNodeIndex(String nodeId, List<String> removeLink) {
        energyIndexMapper.removeNodeIndex(nodeId, removeLink);
    }

    @Override
    public AjaxResult importEnergyIndex(List<EnergyIndex> energyIndexList, boolean updateSupport) {
        List<String> codes = energyIndexList.stream().map(EnergyIndex::getCode)
                .collect(Collectors.toList());
        List<String> nodeCodes = energyIndexList.stream().map(EnergyIndex::getNodeId)
                .collect(Collectors.toList());
        List<EnergyIndex> indexList = energyIndexMapper.getEnergyIndexByCodes(codes);
        List<ModelNode> modelNodes = modelNodeService.getModelNodeByNodeCodes(nodeCodes);
        Map<String, String> nodeCodeToId = modelNodes.stream()
                .collect(Collectors.toMap(ModelNode::getCode, ModelNode::getNodeId));
        Set<String> cacheIndexCodes = indexList.stream().map(EnergyIndex::getCode)
                .collect(Collectors.toSet());

        List<EnergyIndex> insertData = new ArrayList<>();
        List<EnergyIndex> updateData = new ArrayList<>();
        List<String> errorNodeCode = new ArrayList<>();
        List<String> insertIndexCode = new ArrayList<>();
        AtomicBoolean existDuplicateCode = new AtomicBoolean(false);
        energyIndexList.forEach(energyIndex -> {
            if (cacheIndexCodes.contains(energyIndex.getCode())) {
                updateData.add(energyIndex);
            } else {
                String nodeCode = energyIndex.getNodeId();
                if (nodeCodeToId.containsKey(nodeCode)) {
                    if (!insertIndexCode.contains(energyIndex.getCode())) {
                        insertIndexCode.add(energyIndex.getCode());
                        energyIndex.setIndexId(UUID.randomUUID().toString());
                        energyIndex.setNodeId(nodeCodeToId.get(nodeCode));
                        insertData.add(energyIndex);
                    } else {
                        existDuplicateCode.set(true);
                    }
                } else if (!errorNodeCode.contains(nodeCode)) {
                    errorNodeCode.add(nodeCode);
                }
            }
        });

        if (updateSupport && !updateData.isEmpty()) {
            updateData.forEach(energyIndexMapper::updateEnergyIndex);
        }

        if (!insertData.isEmpty()) {
            energyIndexMapper.saveEnergyIndex(insertData);
        }

        String errMsg = "";
        if (existDuplicateCode.get()) {
            errMsg += "存在重复的指标编码，已自动过滤！";
        }

        if (!errorNodeCode.isEmpty()) {
            errMsg += String.join(",", errorNodeCode) + "没有找到对应的节点数据，因此其下的所有指标导入失败！";
        }

        if (StringUtils.isNotBlank(errMsg)) {
            return AjaxResult.error(errMsg);
        }
        return AjaxResult.success("导入成功！");
    }

    @Override
    public List<EnergyIndex> getEnergyIndexMeterByCodes(List<String> indexCodes) {
        if (indexCodes.isEmpty()) {
            return new ArrayList<>();
        }

        return energyIndexMapper.getEnergyIndexMeterByCodes(indexCodes);
    }

    /**
     * @param query
     * @param pageNum
     * @param pageSize
     * @return com.baomidou.mybatisplus.extension.plugins.pagination.Page<com.zhitan.model.domain.EnergyIndex>
     * @description: hmj åˆ†é¡µæŸ¥è¯¢
     * @author: hmj
     * @date: 2024/10/11 23:56
     */
    @Override
    public Page<EnergyIndex> selectEnergyIndexPage(EnergyIndexQuery query, Long pageNum, Long pageSize) {
        return energyIndexMapper.selectEnergyIndexPage(new Page<>(pageNum, pageSize), query);
    }

    @Override
    public Page<EnergyIndex> getMeterIndexList(List<String> meterIndexIds, String code,
                                               String name, Long pageNum, Long pageSize) {
        LambdaQueryWrapper<EnergyIndex> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(EnergyIndex::getMeterId, meterIndexIds);
        queryWrapper.like(StringUtils.isNotEmpty(code), EnergyIndex::getCode, code);
        queryWrapper.like(StringUtils.isNotEmpty(name), EnergyIndex::getName, name);
        return energyIndexMapper.selectPage(new Page<>(pageNum, pageSize), queryWrapper);
    }

    @Override
    public List<EnergyIndex> getIndexByCode(String code, String nodeId) {
        List<EnergyIndex> energyIndexList = energyIndexMapper.getIndexByCode(code, nodeId);

        return energyIndexList;
    }

    /**
     * æ ¹æ®ç”¨èƒ½å•å…ƒid和设备id，以及点位编码获取点位
     *
     * @param nodeId    èŠ‚点id
     * @param meterId   è®¾å¤‡id
     * @param indexCode ç‚¹ä½ç¼–码或者点位编码的一部分
     * @return
     */
    @Override
    public EnergyIndex getDeviceIndexByCode(String nodeId, String meterId, String indexCode) {

        List<EnergyIndex> energyIndexList = listDeviceIndexByCode(nodeId, meterId, indexCode);
        EnergyIndex energyIndex = energyIndexList.stream().findFirst().orElse(null);
        if (ObjectUtils.isEmpty(energyIndex)) {
            energyIndex = new EnergyIndex();
        }
        return energyIndex;
    }

    /**
     * æ ¹æ®ç”¨èƒ½å•å…ƒid和设备id，以及点位编码获取点位
     *
     * @param nodeId    èŠ‚点id
     * @param meterId   è®¾å¤‡id
     * @param indexCode ç‚¹ä½ç¼–码或者点位编码的一部分
     * @return
     */
    public List<EnergyIndex> listDeviceIndexByCode(String nodeId, String meterId, String indexCode) {
        return energyIndexMapper.selectList(Wrappers.<EnergyIndex>lambdaQuery()
                .eq(EnergyIndex::getNodeId, nodeId)
                .eq(EnergyIndex::getMeterId, meterId)
                .like(EnergyIndex::getCode, indexCode));
    }

    /**
     * æ ¹æ®ç”¨èƒ½å•å…ƒid和设备id，以及点位编码获取点位
     *
     * @param nodeId  èŠ‚点id
     * @param meterId è®¾å¤‡id
     * @return
     */
    @Override
    public List<EnergyIndex> listDeviceIndex(String nodeId, String meterId) {
        return energyIndexMapper.selectList(Wrappers.<EnergyIndex>lambdaQuery()
                .eq(EnergyIndex::getNodeId, nodeId)
                .eq(EnergyIndex::getMeterId, meterId));
    }
}

 zhitan-system/src/main/java/com/zhitan/realtimedata/service/RealtimeDatabaseService.java

@@ -2,6 +2,7 @@


import com.zhitan.common.enums.CollectionModes;
import com.zhitan.common.enums.GroupTimeType;
import com.zhitan.common.enums.RetrievalModes;
import com.zhitan.realtimedata.domain.TagValue;

@@ -94,6 +95,18 @@
                              CollectionModes collectionModes);

    /**
     * èŽ·å–测点在一段时间内按照某一时间周期的统计数据.
     *
     * @param tagCodes  æµ‹ç‚¹ç¼–号集合
     * @param beginTime å¼€å§‹æ—¶é—´
     * @param endTime   ç»“束时间,包括结束时间
     * @param modes ç»Ÿè®¡ç±»åž‹
     * @param timeType  åˆ†ç»„时间周期（分、时、天）
     * @return æµ‹ç‚¹ç»Ÿè®¡ç»“æžœ
     */
    List<TagValue> statistics(String tagCodes, Date beginTime, Date endTime, CollectionModes modes, GroupTimeType timeType);

    /**
     * å­˜å‚¨æµ‹ç‚¹çš„实时数据.
     *
     * @param tagValues æµ‹ç‚¹å®žæ—¶æ•°æ®

 zhitan-system/src/main/java/com/zhitan/realtimedata/service/impl/RealtimeDatabaseServiceImpl.java

@@ -1,7 +1,10 @@
package com.zhitan.realtimedata.service.impl;

import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import com.google.common.collect.Lists;
import com.zhitan.common.enums.CollectionModes;
import com.zhitan.common.enums.GroupTimeType;
import com.zhitan.common.enums.RetrievalModes;
import com.zhitan.realtimedata.data.RealtimeDatabaseManager;
import com.zhitan.realtimedata.data.influxdb.InfluxDBRepository;
@@ -10,9 +13,7 @@
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.stereotype.Service;

import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.*;

/**
 * å®žæ—¶æ•°æ®åº“取数服务实现类.
@@ -131,6 +132,20 @@
        return repository.statistics(tagCodes, beginTime, endTime, collectionModes);
    }

    @Override
    public List<TagValue> statistics(String tagCodes, Date beginTime, Date endTime, CollectionModes modes, GroupTimeType timeType) {
        try {
            List<String> tagCodeList = Arrays.asList(tagCodes.split(StrUtil.COMMA).clone());
            List<TagValue> tagValues = repository.statistics(tagCodeList, beginTime, endTime, modes, timeType);
            if (ObjectUtil.isEmpty(tagValues)) {
                tagValues = new ArrayList<>();
            }
            return tagValues;
        } catch (Exception e) {
            return new ArrayList<>();
        }
    }

    /**
     * å­˜å‚¨æµ‹ç‚¹çš„实时数据.
     *

 zhitan-system/src/main/java/com/zhitan/statisticalAnalysis/domain/dto/FlowChartsDTO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,57 @@
package com.zhitan.statisticalAnalysis.domain.dto;

import com.baomidou.mybatisplus.annotation.EnumValue;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.zhitan.common.enums.TimeType;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.format.annotation.DateTimeFormat;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.time.LocalDate;

/**
 * èƒ½æµå›¾æŸ¥è¯¢
 */
@Data
public class FlowChartsDTO {

    /**
     * èƒ½æºç±»åž‹åç§°
     */
    @EnumValue
    @ApiModelProperty(value = "时间类型")
    private TimeType timeType;

    /**
     * æŸ¥è¯¢æ—¶é—´
     */
    @NotNull(message = "查询时间不能为空")
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    @JsonFormat(pattern = "yyyy-MM-dd")
    @ApiModelProperty(value = "查询时间")
    private LocalDate queryTime;

    /**
     * èƒ½æºç±»åž‹
     */
    @NotBlank(message = "能源类型不能为空")
    @ApiModelProperty(value = "能源类型")
    private String energyType;

    /**
     * èŠ‚点id
     */
    @NotBlank(message = "节点id不能为空")
    @ApiModelProperty(value = "节点id")
    private String nodeId;

    public TimeType getTimeType() {
        if (ObjectUtils.isEmpty(timeType)) {
            return TimeType.DAY;
        }
        return timeType;
    }
}

 zhitan-system/src/main/java/com/zhitan/statisticalAnalysis/domain/vo/FlowChartsItemVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,34 @@
package com.zhitan.statisticalAnalysis.domain.vo;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import javax.validation.constraints.NotBlank;
import java.math.BigDecimal;

/**
 * èƒ½æµå›¾æŸ¥è¯¢
 */
@Data
public class FlowChartsItemVO {

    /**
     * æºå¤´
     */
    @ApiModelProperty(value = "源头")
    private String source;

    /**
     * ç›®æ ‡
     */
    @ApiModelProperty(value = "目标")
    private String target;

    /**
     * å€¼
     */
    @NotBlank(message = "值")
    @ApiModelProperty(value = "值")
    private BigDecimal value;

}

 zhitan-system/src/main/java/com/zhitan/statisticalAnalysis/domain/vo/FlowChartsVO.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,68 @@
package com.zhitan.statisticalAnalysis.domain.vo;

import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Collections;
import java.util.List;

/**
 * èƒ½æµå›¾æŸ¥è¯¢
 */
@Data
public class FlowChartsVO {

    // æ€»ç´¯ç§¯é‡
    @ApiModelProperty(value = "总累积量")
    private BigDecimal totalAccumulatedAmount;

    // å­èŠ‚点累积量
    @ApiModelProperty(value = "子节点累积量")
    private BigDecimal childNodeAccumulatedAmount;

    // å·®å€¼
    @ApiModelProperty(value = "差值")
    private BigDecimal difference;

    // èƒ½è€—损失比例
    @ApiModelProperty(value = "能耗损失比例")
    private BigDecimal energyLossRatio;

    private List<FlowChartsItemVO> itemVOList;

    public BigDecimal getTotalAccumulatedAmount() {
        if (totalAccumulatedAmount == null){
            return BigDecimal.ZERO;
        }
        return totalAccumulatedAmount;
    }

    public BigDecimal getChildNodeAccumulatedAmount() {
        if (childNodeAccumulatedAmount == null){
            return BigDecimal.ZERO;
        }
        return childNodeAccumulatedAmount;
    }

    public BigDecimal getDifference() {
        return difference = totalAccumulatedAmount.subtract(childNodeAccumulatedAmount);
    }

    public BigDecimal getEnergyLossRatio() {
        if (BigDecimal.ZERO.compareTo(totalAccumulatedAmount) == 0
                || BigDecimal.ZERO.compareTo(difference) == 0){
            return BigDecimal.ZERO;
        }
        return energyLossRatio = difference.divide(totalAccumulatedAmount, 2, RoundingMode.HALF_UP);
    }

    public FlowChartsVO() {
        this.totalAccumulatedAmount = BigDecimal.ZERO;
        this.childNodeAccumulatedAmount = BigDecimal.ZERO;
        this.difference = BigDecimal.ZERO;
        this.energyLossRatio = BigDecimal.ZERO;
        this.itemVOList = Collections.emptyList();
    }
}

 zhitan-system/src/main/resources/mapper/comprehensivestatistics/DailyComprehensiveMapper.xml

@@ -35,7 +35,7 @@
        <result column="value0" property="value0"/>
    </resultMap>
    <!--全厂能耗统计-->
    <select id="getdailyComprehensiveList" resultMap="dataItemMap">
    <select id="getDailyComprehensiveList" resultType="com.zhitan.comprehensivestatistics.domain.DailyComprehensive">
        SELECT
            aa.index_id,
            aa.index_name,
@@ -72,7 +72,7 @@
        ORDER BY aa.order_num ASC
    </select>

    <select id="getListChart" resultMap="dataItemMap">
    <select id="getListChart" resultType="com.zhitan.comprehensivestatistics.domain.DailyComprehensive">
        SELECT
            di.index_id,
            ci.name AS "index_name",

 zhitan-system/src/main/resources/mapper/model/ModelNodeMapper.xml

@@ -89,9 +89,9 @@
            resultType="com.zhitan.model.domain.EnergyIndex">
        select ei.index_id as indexId, code, name, index_type as indexType
        from energy_index ei
                 left join node_index ni on ei.index_id = ni.index_id
        left join node_index ni on ei.index_id = ni.index_id
        where ni.node_id = #{nodeId}
          and ei.index_type = #{indexType}
        and ei.index_type = #{indexType}
        <if test="code != null  and code != ''">
            and code like concat('%', #{code}, '%')
        </if>
@@ -332,11 +332,12 @@
               node_category nodeCategory
        FROM "model_node"
        WHERE model_code = #{indexCode}
          AND parent_id IS NULL LIMIT 1;
          AND parent_id IS NULL
        LIMIT 1;
    </select>
    <select id="selectIndexByModelCodeAndNodeId"
            resultType="com.zhitan.model.domain.vo.ModelNodeIndexInfor">
        SELECT mn.node_id nodeId,
        SELECT mn.node_id  nodeId,
               mn."name",
               ni.index_id indexId
        FROM model_node mn
@@ -347,15 +348,15 @@

    <select id="getSettingDeviceIndex" resultType="com.zhitan.basicdata.domain.MeterImplement">
        SELECT distinct
               m."id",
               m.code,
               m.meter_name AS meterName,
               m.meter_type    meterType,
               m.wire_diameter    wireDiameter,
               m.max_allowable_power    maxAllowablePower
        m."id",
        m.code,
        m.meter_name AS meterName,
        m.meter_type meterType,
        m.wire_diameter wireDiameter,
        m.max_allowable_power maxAllowablePower
        FROM meter_implement m
                 LEFT JOIN energy_index ei ON ei.meter_id = m."id"
                 LEFT JOIN node_index ni ON ni.index_id = ei.index_id
        LEFT JOIN energy_index ei ON ei.meter_id = m."id"
        LEFT JOIN node_index ni ON ni.index_id = ei.index_id
        WHERE ni.node_id = #{nodeId}
        <if test="energyType!=null and energyType!=''">
            AND M.energy_type = #{energyType}
@@ -365,11 +366,12 @@
    <delete id="delIndexNodeIdAndIndexType">
        delete
        from node_index
        where node_id = #{nodeId} and index_id in (
            select ni.index_id
            from node_index ni left join energy_index ei on ni.index_id = ei.index_id
            where node_id = #{nodeId} and ei.index_type = #{indexType}
        );
        where node_id = #{nodeId}
          and index_id in (select ni.index_id
                           from node_index ni
                                    left join energy_index ei on ni.index_id = ei.index_id
                           where node_id = #{nodeId}
                             and ei.index_type = #{indexType});
    </delete>
    <insert id="setIndexAndNodeId">
        <foreach collection="indexIds" item="indexId" separator=";">
@@ -379,11 +381,11 @@
    </insert>

    <select id="getModelNodeIndexIdByNodeId" resultType="com.zhitan.model.domain.vo.ModelNodeIndexInfor">
        SELECT mn.node_id  nodeId,
               mn."name"   "name",
               ni.index_id indexId,
               ei.energy_id energyId,
               ei.index_type indexType
        SELECT mn.node_id nodeId,
        mn."name" "name",
        ni.index_id indexId,
        ei.energy_id energyId,
        ei.index_type indexType
        FROM "model_node" mn
        LEFT JOIN "node_index" ni ON mn.node_id = ni.node_id
        LEFT JOIN energy_index ei on ni.index_id = ei.index_id
@@ -400,16 +402,17 @@
        FROM "model_node" mn
                 LEFT JOIN "node_index" ni ON mn.node_id = ni.node_id
                 left join energy_index ei on ni.index_id = ei.index_id
        WHERE mn.parent_id = #{parentId} and ei.index_type = 'STATISTIC'
        WHERE mn.parent_id = #{parentId}
          and ei.index_type = 'STATISTIC'
    </select>
    <select id="getFirstModeNodeInfo" resultType="com.zhitan.model.domain.ModelNode">
        <include refid="selectModelNodeVo"/>
        where model_code = #{modelCode}  AND parent_id is null
        where model_code = #{modelCode} AND parent_id is null
        order by order_num
    </select>
    <select id="selectIndexByNodeIds" resultType="com.zhitan.model.domain.vo.ModelNodeIndexInfor">
        SELECT mn.node_id  nodeId,
        mn."name"   "name",
        SELECT mn.node_id nodeId,
        mn."name" "name",
        ni.index_id indexId,
        ei.energy_id
        FROM "model_node" mn
@@ -417,15 +420,49 @@
        left join energy_index ei on ni.index_id = ei.index_id
        <where>
            mn.model_code = #{modelCode}
          AND mn.node_id in
        <foreach collection="nodeIds" index="index" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
        <if test="modelCode!=null and modelCode!='' and nodeIds.size>0">
            and ei.index_type='STATISTIC'
        </if>
            AND mn.node_id in
            <foreach collection="nodeIds" index="index" item="item" open="(" separator="," close=")">
                #{item}
            </foreach>
            <if test="modelCode!=null and modelCode!='' and nodeIds.size>0">
                and ei.index_type='STATISTIC'
            </if>

        </where>

    </select>

    <select id="getDataItemByParentNodeId" resultType="com.zhitan.dataitem.domain.vo.NodeIndexValueVO">
        SELECT mn.node_id  nodeId,
               mn."name"   nodeName,
               di.index_id indexId,
               di."value"  value
        FROM model_node mn
                 LEFT JOIN "node_index" ni ON mn.node_id = ni.node_id
                 LEFT JOIN "energy_index" ei ON ei.index_id = ni.index_id
                 LEFT JOIN "data_item" di ON ei.index_id = di.index_id
        WHERE mn.parent_id = #{parentId}
          AND ei.energy_id = #{energyType}
          AND ei.index_type = 'STATISTIC'
          AND di.time_type = #{timeType.name}
          AND di.data_time >= #{dateTimeMap.startTime}
          AND di.data_time &lt;= #{dateTimeMap.endTime}
    </select>

    <select id="getDataItemByNodeId" resultType="com.zhitan.dataitem.domain.vo.NodeIndexValueVO">
        SELECT mn.node_id  nodeId,
               mn."name"   nodeName,
               di.index_id indexId,
               di."value"  value
        FROM "model_node" mn
                 LEFT JOIN "node_index" ni ON mn.node_id = ni.node_id
                 LEFT JOIN "energy_index" ei ON ei.index_id = ni.index_id
                 LEFT JOIN "data_item" di ON ei.index_id = di.index_id
        WHERE mn.node_id = #{nodeId}
          AND ei.energy_id = #{energyType}
          AND ei.index_type = 'STATISTIC'
          AND di.time_type = #{timeType.name}
          AND di.data_time >= #{dateTimeMap.startTime}
          AND di.data_time &lt;= #{dateTimeMap.endTime}
    </select>
</mapper>

 zhitan-system/src/main/resources/mapper/model/NodeIndexMapper.xml

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,10 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.zhitan.model.mapper.NodeIndexMapper">

    <resultMap type="com.zhitan.model.domain.NodeIndex" id="NodeIndexMap">
        <result property="nodeId" column="node_id" jdbcType="VARCHAR"/>
        <result property="indexId" column="index_id" jdbcType="VARCHAR"/>
    </resultMap>
</mapper>