功率因数

DYL

2025-02-10 d8d91ebc9ee8266373dbadcbde05cc614880ad38

功率因数

 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-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/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/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/model/service/impl/EnergyIndexServiceImpl.java

@@ -35,320 +35,320 @@
@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 += "存在重复的指标编码，已自动过滤！";
    /**
     * æŸ¥è¯¢æŒ‡æ ‡ä¿¡æ¯åˆ—表
     *
     * @param energyIndex æŒ‡æ ‡ä¿¡æ¯
     * @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);
  }

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

  /**
   * æ ¹æ®ç”¨èƒ½å•å…ƒid和设备id，以及点位编码获取点位
   *
   * @param energyUnitId ç”¨èƒ½å•å…ƒid
   * @param meterId      è®¾å¤‡id
   * @param indexCode    ç‚¹ä½ç¼–码或者点位编码的一部分
   * @return
   */
  public List<EnergyIndex> listDeviceIndexByCode(String energyUnitId, String meterId, String indexCode) {
    return energyIndexMapper.selectList(Wrappers.<EnergyIndex>lambdaQuery()
            .eq(EnergyIndex::getNodeId, energyUnitId)
            .eq(EnergyIndex::getMeterId, meterId)
            .like(EnergyIndex::getCode, indexCode));
  }
    @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("找不到对应的计量器具！");
        }

        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));
    }
}