baoshiwei
2025-04-19 5d36e1f987ef21e44ded2e8a1d06c28094ec1e76
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package com.zhitan.model.service.impl;
 
import com.zhitan.basicdata.domain.MeterImplement;
import com.zhitan.basicdata.services.IMeterImplementService;
import com.zhitan.model.domain.EnergyIndex;
import com.zhitan.model.domain.ModelInfo;
import com.zhitan.model.domain.vo.ModelNodeIndexInfo;
import com.zhitan.model.domain.vo.PointDataVO;
import com.zhitan.model.mapper.ModelInfoMapper;
import com.zhitan.model.service.IEnergyIndexService;
import com.zhitan.model.service.IModelInfoService;
import com.zhitan.model.service.IModelNodeService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
 
/**
 * 模型Service业务层处理
 *
 * @author fanxinfu
 * @date 2020-02-17
 */
@Service
public class ModelInfoServiceImpl implements IModelInfoService {
  @Autowired
  private ModelInfoMapper modelInfoMapper;
 
  @Autowired
  private final IModelNodeService modelNodeService;
 
  @Autowired
  private final IEnergyIndexService energyIndexService;
 
  @Autowired
  private final IMeterImplementService meterImplementService;
 
  public ModelInfoServiceImpl(IModelNodeService modelNodeService,
                              IEnergyIndexService energyIndexService,
                              IMeterImplementService meterImplementService) {
    this.modelNodeService = modelNodeService;
    this.energyIndexService = energyIndexService;
    this.meterImplementService = meterImplementService;
  }
 
  /**
   * 查询模型
   *
   * @param modelCode 模型ID
   * @return 模型
   */
  @Override
  public ModelInfo selectModelInfoById(String modelCode) {
    return modelInfoMapper.selectModelInfoById(modelCode);
  }
 
  /**
   * 查询模型列表
   *
   * @param modelInfo 模型
   * @return 模型
   */
  @Override
  public List<ModelInfo> selectModelInfoList(ModelInfo modelInfo) {
    return modelInfoMapper.selectModelInfoList(modelInfo);
  }
 
  /**
   * 新增模型
   *
   * @param modelInfo 模型
   * @return 结果
   */
  @Override
  public int insertModelInfo(ModelInfo modelInfo) {
    return modelInfoMapper.insertModelInfo(modelInfo);
  }
 
  /**
   * 修改模型
   *
   * @param modelInfo 模型
   * @return 结果
   */
  @Override
  public int updateModelInfo(ModelInfo modelInfo) {
    return modelInfoMapper.updateModelInfo(modelInfo);
  }
 
  /**
   * 批量删除模型
   *
   * @param modelCode 需要删除的模型ID
   * @return 结果
   */
  @Override
  public int deleteModelInfoByCode(String modelCode) {
    return modelInfoMapper.deleteModelInfoByCode(modelCode);
  }
 
  /**
   * 删除模型信息
   *
   * @param modelCode 模型ID
   * @return 结果
   */
  @Override
  public int deleteModelInfoById(String modelCode) {
    return modelInfoMapper.deleteModelInfoById(modelCode);
  }
 
  /**
   * 根据模型id查询对应点位信息
   *
   * @param modelId 查询模型id
   * @return
   */
  @Override
  public List<PointDataVO> listEnergyIndexByModelId(String modelId) {
    List<PointDataVO> voList = new ArrayList<>();
    // 根据id查询下级id与indexId
    List<ModelNodeIndexInfo> inforList = modelNodeService.listModelNodeIndexIdRelationInforByParentId(modelId);
    if (CollectionUtils.isEmpty(inforList)) {
      List<ModelNodeIndexInfo> indexInforList = modelNodeService.getModelNodeIndexIdRelationInforByNodeId(modelId);
      if (CollectionUtils.isEmpty(indexInforList)) {
        return voList;
      }
      inforList.addAll(indexInforList);
    }
    // 去除所有点位id信息
    List<String> indexIds = inforList.stream().map(ModelNodeIndexInfo::getIndexId).collect(Collectors.toList());
    List<EnergyIndex> energyIndexList = energyIndexService.getEnergyIndexByIds(indexIds);
    // 根据indexid查询对应计量器具信息
    List<String> meterIds = energyIndexList.stream().map(EnergyIndex::getMeterId).collect(Collectors.toList());
    Map<String, List<MeterImplement>> meterImplementMap = meterImplementService.listMeterImplementByIds(meterIds).stream()
            .filter(li -> StringUtils.isNotEmpty(li.getInstallactionLocation()))
            .collect(Collectors.groupingBy(MeterImplement::getId));
    for (EnergyIndex indexInfo : energyIndexList) {
 
      PointDataVO pointData = new PointDataVO();
      String indexName = indexInfo.getName();
      List<MeterImplement> meterImplements = meterImplementMap.get(indexInfo.getMeterId());
      if (CollectionUtils.isNotEmpty(meterImplements)) {
        MeterImplement infor = meterImplements.get(0);
        indexName = infor.getInstallactionLocation() + "_" + infor.getMeterName() + "_" + indexName;
      }
      pointData.setIndexName(indexName);
      pointData.setIndexId(indexInfo.getIndexId());
      voList.add(pointData);
    }
    return voList;
  }
}