package com.zhitan.model.service.impl;
|
|
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
|
import com.zhitan.basicdata.domain.MeterImplement;
|
import com.zhitan.basicdata.domain.SysEnergy;
|
import com.zhitan.basicdata.domain.SysProduct;
|
import com.zhitan.model.domain.EnergyIndex;
|
import com.zhitan.model.domain.ModelNode;
|
import com.zhitan.model.domain.TreeObject;
|
import com.zhitan.model.domain.vo.ModelNodeIndexInfo;
|
import com.zhitan.model.mapper.ModelNodeMapper;
|
import com.zhitan.model.service.IEnergyIndexService;
|
import com.zhitan.model.service.IModelNodeService;
|
import org.apache.commons.collections4.CollectionUtils;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.stereotype.Service;
|
|
import java.util.Collections;
|
import java.util.HashMap;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.stream.Collectors;
|
|
import static org.apache.commons.lang3.StringUtils.equalsAnyIgnoreCase;
|
import static org.apache.commons.lang3.StringUtils.isBlank;
|
|
/**
|
* 模型节点Service业务层处理
|
*
|
* @author fanxinfu
|
* @date 2020-02-10
|
*/
|
@Service
|
public class ModelNodeServiceImpl implements IModelNodeService {
|
|
@Autowired
|
private ModelNodeMapper modelNodeMapper;
|
|
@Autowired
|
private IEnergyIndexService energyIndexService;
|
|
/**
|
* 查询模型节点
|
*
|
* @param nodeId 模型节点ID
|
* @return 模型节点
|
*/
|
@Override
|
public ModelNode selectModelNodeById(String nodeId) {
|
return modelNodeMapper.selectModelNodeById(nodeId);
|
}
|
|
/**
|
* 查询模型节点列表
|
*
|
* @param modelNode 模型节点
|
* @return 模型节点
|
*/
|
@Override
|
public List<ModelNode> selectModelNodeList(ModelNode modelNode) {
|
return modelNodeMapper.selectModelNodeList(modelNode);
|
}
|
|
/**
|
* 新增模型节点
|
*
|
* @param modelNode 模型节点
|
* @return 结果
|
*/
|
@Override
|
public int insertModelNode(ModelNode modelNode) {
|
int maxOrder = modelNodeMapper.getMaxOrder(modelNode.getParentId());
|
modelNode.setOrderNum(maxOrder + 1);
|
return modelNodeMapper.insertModelNode(modelNode);
|
}
|
|
/**
|
* 修改模型节点
|
*
|
* @param modelNode 模型节点
|
* @return 结果
|
*/
|
@Override
|
public int updateModelNode(ModelNode modelNode) {
|
return modelNodeMapper.updateModelNode(modelNode);
|
}
|
|
/**
|
* 批量删除模型节点
|
*
|
* @param nodeIds 需要删除的模型节点ID
|
* @return 结果
|
*/
|
@Override
|
public int deleteModelNodeByIds(String[] nodeIds) {
|
return modelNodeMapper.deleteModelNodeByIds(nodeIds);
|
}
|
|
/**
|
* 删除模型节点信息
|
*
|
* @param nodeId 模型节点ID
|
* @return 结果
|
*/
|
@Override
|
public int deleteModelNodeById(String nodeId) {
|
return modelNodeMapper.deleteModelNodeById(nodeId);
|
}
|
|
@Override
|
public List<ModelNode> getModelNodeByModelCode(String modelCode) {
|
return modelNodeMapper.getModelNodeByModelCode(modelCode);
|
}
|
|
@Override
|
public List<TreeObject> buildModelNodeTree(List<ModelNode> modelNodes) {
|
List<ModelNode> modelNodeTree = modelNodes.stream()
|
.filter(f -> isBlank(f.getParentId()))
|
.collect(Collectors.toList());
|
for (ModelNode modelNode : modelNodeTree) {
|
List<ModelNode> children = modelNodes.stream()
|
.filter(f -> equalsAnyIgnoreCase(f.getParentId(), modelNode.getNodeId()))
|
.collect(Collectors.toList());
|
buildTree(modelNode, children, modelNodes);
|
}
|
|
return modelNodeTree.stream().map(TreeObject::new).collect(Collectors.toList());
|
}
|
|
@Override
|
public void updateOrder(String nodeId, String parentId, String[] children) {
|
modelNodeMapper.updateModelNodeParent(nodeId, parentId);
|
Map<String, Integer> orders = new HashMap<>();
|
for (int i = 0; i < children.length; i++) {
|
orders.put(children[i], i);
|
}
|
modelNodeMapper.updateModelNodeOrder(orders);
|
}
|
|
@Override
|
public boolean modelNodeHasExist(String code, String modelCode) {
|
int count = modelNodeMapper.modelNodeHasExist(code, modelCode);
|
return count > 0;
|
}
|
|
@Override
|
public boolean modelNodeHasExist(ModelNode modelNode) {
|
int count = modelNodeMapper
|
.modelNodeHasExistWhenUpdate(modelNode.getNodeId(), modelNode.getCode(),
|
modelNode.getModelCode());
|
return count > 0;
|
}
|
|
@Override
|
public boolean hasEnergyIndex(String nodeId) {
|
EnergyIndex energyIndex = new EnergyIndex();
|
energyIndex.setNodeId(nodeId);
|
List<EnergyIndex> energyIndices = energyIndexService.selectEnergyIndexList(energyIndex);
|
return energyIndices.size() > 0;
|
}
|
|
@Override
|
public void setDevice(String nodeId, String[] deviceIds) {
|
modelNodeMapper.setDevice(nodeId, deviceIds);
|
}
|
|
@Override
|
public List<MeterImplement> getSettingDevice(String nodeId) {
|
return modelNodeMapper.getSettingDevice(nodeId);
|
}
|
|
@Override
|
public List<EnergyIndex> getSettingIndex(String nodeId) {
|
return modelNodeMapper.getSettingIndex(nodeId);
|
}
|
|
@Override
|
public List<EnergyIndex> getSettingIndexByWhere(String nodeId,String indexName) {
|
return modelNodeMapper.getSettingIndexByWhere(nodeId,indexName);
|
}
|
|
@Override
|
public void delDevice(String nodeId, String[] deviceIds) {
|
if (deviceIds.length == 0) {
|
return;
|
}
|
|
modelNodeMapper.delDevice(nodeId, deviceIds);
|
}
|
|
@Override
|
public List<SysEnergy> getSettingEnergy(String nodeId) {
|
return modelNodeMapper.getSettingEnergy(nodeId);
|
}
|
|
@Override
|
public void setEnergy(String nodeId, Integer[] energyIds) {
|
modelNodeMapper.setEnergy(nodeId, energyIds);
|
}
|
|
@Override
|
public void delEnergy(String nodeId, Integer[] energyIds) {
|
if (energyIds.length == 0) {
|
return;
|
}
|
|
modelNodeMapper.delEnergy(nodeId, energyIds);
|
}
|
|
@Override
|
public List<SysProduct> getSettingProduct(String nodeId) {
|
return modelNodeMapper.getSettingProduct(nodeId);
|
}
|
|
@Override
|
public void setProduct(String nodeId, Integer[] productIds) {
|
modelNodeMapper.setProduct(nodeId, productIds);
|
}
|
|
@Override
|
public void delProduct(String nodeId, Integer[] productIds) {
|
if (productIds.length == 0) {
|
return;
|
}
|
|
modelNodeMapper.delProduct(nodeId, productIds);
|
}
|
|
@Override
|
public void setIndex(String nodeId, String indexType, String[] indexIds) {
|
modelNodeMapper.delIndexNodeIdAndIndexType(nodeId,indexType);
|
modelNodeMapper.setIndexAndNodeId(nodeId, indexIds);
|
}
|
|
@Override
|
public void delIndex(String nodeId, String[] indexIds) {
|
if (indexIds.length == 0) {
|
return;
|
}
|
|
modelNodeMapper.delIndex(nodeId, indexIds);
|
}
|
|
@Override
|
public Page<EnergyIndex> getSettingIndex(String indexType, String nodeId, String code,
|
String name, Long pageNum, Long pageSize) {
|
return modelNodeMapper.getSettingIndexByType(indexType, nodeId,
|
code,name,
|
new Page<>(pageNum,pageSize));
|
}
|
|
@Override
|
public List<ModelNode> getModelNodeByNodeCodes(List<String> nodeCodes) {
|
return modelNodeMapper.getModelNodeByNodeCodes(nodeCodes);
|
}
|
|
@Override
|
public List<ModelNode> getModelNodeByModelCodeWithAuth(String modelCode, Long userId) {
|
return modelNodeMapper.getModelNodeByModelCodeWithAuth(modelCode, String.valueOf(userId));
|
}
|
|
/**
|
* 根据nodeCode获取对应点位信息
|
*
|
* @param nodeCode
|
* @return
|
*/
|
@Override
|
public List<String> listIndexIdsByModelCode(String nodeCode) {
|
// 根据code获取modelNode信息
|
List<ModelNode> modelNodeList = getModelNodeByModelCode(nodeCode);
|
if (CollectionUtils.isEmpty(modelNodeList)) {
|
return Collections.emptyList();
|
}
|
List<String> nodeIds = modelNodeList.stream().map(ModelNode::getNodeId).collect(Collectors.toList());
|
|
return modelNodeMapper.listIndesxByCodeList(nodeIds);
|
}
|
|
/**
|
* 根据nodeCode查询模型节点与点位id之间的关系信息
|
*
|
* @param code
|
* @return
|
*/
|
@Override
|
public List<ModelNodeIndexInfo> getModelNodeIndexIdRelationInforByCode(String code) {
|
return modelNodeMapper.getModelNodeIndexIdRelationInforByCode(code);
|
}
|
|
/**
|
* 根据nodeId查询对应详细信息
|
*
|
* @param nodeId
|
* @return
|
*/
|
@Override
|
public List<ModelNodeIndexInfo> getModelNodeIndexIdRelationInforByNodeId(String nodeId) {
|
return modelNodeMapper.getModelNodeIndexIdRelationInforByNodeId(nodeId);
|
}
|
|
/**
|
* 根据父id查询详细信息
|
*
|
* @param parentId
|
* @return
|
*/
|
@Override
|
public List<ModelNodeIndexInfo> listModelNodeIndexIdRelationInforByParentId(String parentId) {
|
return modelNodeMapper.listModelNodeIndexIdRelationInforByParentId(parentId);
|
}
|
|
/**
|
* 根据code查询父级信息
|
*
|
* @param indexCode
|
* @return
|
*/
|
@Override
|
public ModelNode getModelNodeByModelCodeByIndexCode(String indexCode) {
|
return modelNodeMapper.getModelNodeByModelCodeByIndexCode(indexCode);
|
}
|
|
private void buildTree(ModelNode parent, List<ModelNode> children, List<ModelNode> modelNodes) {
|
parent.setChildren(children);
|
|
for (ModelNode modelNode : children) {
|
List<ModelNode> tmp = modelNodes.stream()
|
.filter(f -> equalsAnyIgnoreCase(f.getParentId(), modelNode.getNodeId()))
|
.collect(Collectors.toList());
|
if (!tmp.isEmpty()) {
|
buildTree(modelNode, tmp, modelNodes);
|
}
|
}
|
}
|
|
@Override
|
public Page<EnergyIndex> getIndexByMeterImplement(String nodeId,
|
String code,
|
String name,
|
Long pageNum,
|
Long pageSize) {
|
|
final List<MeterImplement> settingDevice = modelNodeMapper.getSettingDevice(nodeId);
|
if(CollectionUtils.isEmpty(settingDevice)){
|
return new Page<EnergyIndex>();
|
}
|
final List<String> meterImpIds = settingDevice.stream().map(MeterImplement::getId).collect(Collectors.toList());
|
final Page<EnergyIndex> energyIndexByIds = energyIndexService.getMeterIndexList(meterImpIds,code,name,pageNum,pageSize);
|
|
return energyIndexByIds;
|
}
|
|
@Override
|
public List<MeterImplement> getSettingDeviceIndex(String nodeId, String energyType) {
|
return modelNodeMapper.getSettingDeviceIndex(nodeId,energyType);
|
}
|
}
|