package com.estate.expert.admin.service.impl;
|
|
import com.estate.expert.admin.domain.common.IDtoBase;
|
import com.estate.expert.admin.domain.standard.expert.Expert;
|
import com.estate.expert.admin.domain.standard.expert.matrix.CompareMatrix;
|
import com.estate.expert.admin.domain.standard.expert.matrix.MembershipMatrix;
|
import com.estate.expert.admin.domain.standard.expert.matrix.MembershipMatrixRowDto;
|
import com.estate.expert.admin.domain.standard.expert.matrix.WeightMatrixRow;
|
import com.estate.expert.admin.domain.standard.hierachy.HierarchyData;
|
import com.estate.expert.admin.domain.user.User;
|
import com.estate.expert.admin.enums.BizResultCode;
|
import com.estate.expert.admin.io.processor.impl.matrix.CompareMatrixProcessor;
|
import com.estate.expert.admin.io.processor.impl.matrix.MembershipMatrixProcessor;
|
import com.estate.expert.admin.service.common.CrudServiceBaseImpl;
|
import com.estate.expert.admin.service.expert.ExpertService;
|
import com.estate.expert.admin.utils.Tuple;
|
import com.estate.expert.admin.utils.tree.TreeNode;
|
import com.estate.expert.admin.utils.tree.TreeRoot;
|
import com.estate.expert.admin.utils.tree.helper.TreeHelper;
|
import org.springframework.core.io.ClassPathResource;
|
import org.springframework.util.CollectionUtils;
|
|
import javax.lang.model.type.NullType;
|
import java.io.IOException;
|
import java.io.InputStream;
|
import java.util.ArrayList;
|
import java.util.List;
|
import java.util.Map;
|
import java.util.TreeMap;
|
|
/**
|
* 专家服务实现
|
*/
|
public abstract class ExpertServiceImpl<T extends Expert, D extends IDtoBase>
|
extends CrudServiceBaseImpl<T, D> implements ExpertService<T, D> {
|
|
@Override
|
public void editWeightMap(Integer expertId, String hierarchyPath, Float weight) {
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
if(expert.getWeightMap() == null)
|
expert.setWeightMap(new TreeMap<>());
|
expert.getWeightMap().put(hierarchyPath, weight);
|
save(expert);
|
}
|
|
@Override
|
public void editWeightMatrixRow(Integer expertId, WeightMatrixRow row) {
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
|
if(expert.getWeightMap() == null)
|
expert.setWeightMap(new TreeMap<>());
|
|
expert.getWeightMap().put(row.getHierarchyPath(), row.getWeight());
|
save(expert);
|
}
|
|
@Override
|
public void editWeightMatrixRows(Integer expertId, List<WeightMatrixRow> rows) {
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
|
if(expert.getWeightMap() == null)
|
expert.setWeightMap(new TreeMap<>());
|
|
rows.forEach(row -> expert.getWeightMap().put(row.getHierarchyPath(), row.getWeight()));
|
|
save(expert);
|
}
|
|
@Override
|
public Map<String, Tuple<String, Float>> weightMap(Integer expertId, String hierarchyPath) {
|
var res = new TreeMap<String, Tuple<String, Float>>();
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
|
var hierarchyTree = getHierarchyTree(expertId);
|
var weightMap = expert.getWeightMap();
|
var node = hierarchyTree.get(hierarchyPath);
|
BizResultCode.HIERARCHY_NODE_NOT_FOUND.check(node == null);
|
node.getChildren().forEach((key, value) -> {
|
Float weight = value.getData().getWeight();
|
if(weightMap != null && weightMap.containsKey(value.getPath()))
|
{
|
weight = weightMap.get(value.getPath());
|
}
|
res.put(value.getPath(), new Tuple<>(value.getName(), weight));
|
});
|
return res;
|
}
|
|
@Override
|
public List<WeightMatrixRow> weightMatrix(Integer expertId, String hierarchyPath) {
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
|
var weightMatrix = new ArrayList<WeightMatrixRow>();
|
|
var hierarchyTree = getHierarchyTree(expertId);
|
var weightMap = expert.getWeightMap();
|
var node = hierarchyTree.get(hierarchyPath);
|
BizResultCode.HIERARCHY_NODE_NOT_FOUND.check(node == null);
|
node.getChildren().forEach((key, value) -> {
|
Float weight = value.getData().getWeight();
|
if(weightMap != null && weightMap.containsKey(value.getPath()))
|
{
|
weight = weightMap.get(value.getPath());
|
}
|
|
weightMatrix.add(WeightMatrixRow.builder()
|
.name(value.getName())
|
.hierarchyPath(value.getPath())
|
.weight(weight)
|
.build());
|
});
|
return weightMatrix;
|
}
|
|
@Override
|
public MembershipMatrix getMembershipMatrix(Integer expertId) {
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
return expert.getMembershipMatrix();
|
}
|
|
@Override
|
public void editMembershipMatrix(Integer expertId, float[][][][][] data) {
|
MembershipMatrixProcessor.validate(data);
|
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
|
var oldMatrix = expert.getMembershipMatrix();
|
if(oldMatrix != null)
|
oldMatrix.setData(data);
|
else
|
expert.setMembershipMatrix(new MembershipMatrix(null, data));
|
save(expert);
|
}
|
|
@Override
|
public void editMembershipMatrixRow(Integer expertId, MembershipMatrixRowDto row) {
|
MembershipMatrixProcessor.validateRow(row);
|
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
|
var matrix = expert.getMembershipMatrix();
|
BizResultCode.MEMBERSHIP_MATRIX_NOT_EXIST.check(matrix == null);
|
|
var data = matrix.getData();
|
data[row.getP1()][row.getP2()][row.getP3()][row.getP4()] =
|
new float[]{row.getV0(), row.getV1(), row.getV2(), row.getV3(), row.getV4()};
|
save(expert);
|
}
|
|
@Override
|
public List<MembershipMatrixRowDto> listMembershipMatrixRows(Integer expertId, Integer p1, Integer p2, Integer p3, Integer p4) {
|
var matrix = getMembershipMatrix(expertId);
|
return matrix.listRows(p1, p2, p3, p4);
|
}
|
|
@Override
|
public void importMembershipMatrix(Integer expertId, InputStream inputStream) {
|
MembershipMatrix matrix = null;
|
try {
|
matrix = new MembershipMatrixProcessor().loadFromWorkbook(inputStream);
|
editMembershipMatrix(expertId, matrix.getData());
|
} catch (IOException e) {
|
e.printStackTrace();
|
BizResultCode.MEMBERSHIP_MATRIX_LOAD_ERROR.check(true);
|
}
|
BizResultCode.MEMBERSHIP_MATRIX_LOAD_ERROR.check(matrix == null);
|
}
|
|
@Override
|
public CompareMatrix getFuzzyMatrix(Integer expertId, String hierarchyPath) {
|
var hierarchyTree = getHierarchyTree(expertId);
|
var node = hierarchyTree.get(hierarchyPath);
|
BizResultCode.HIERARCHY_NODE_NOT_FOUND.check(node == null);
|
|
var children = node.getChildren();
|
BizResultCode.COMPARE_MATRIX_EMPTY.check(children == null || children.isEmpty());
|
|
var indexCols = children.values().stream().map(TreeNode::getName).toArray(String[]::new);
|
return getFuzzyMatrix(expertId, hierarchyPath, indexCols);
|
}
|
|
@Override
|
public CompareMatrix getFuzzyMatrix(Integer expertId, String hierarchyPath, String[] indexCols) {
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
BizResultCode.INDEX_COLS_EMPTY.check(indexCols == null || indexCols.length == 0);
|
|
if(expert.getCompareMatrixMap() == null)
|
return new CompareMatrix(indexCols);
|
|
var compareMatrix = expert.getCompareMatrixMap().get(hierarchyPath);
|
if(compareMatrix == null)
|
return new CompareMatrix(indexCols);
|
|
return compareMatrix.subMatrix(indexCols);
|
}
|
|
@Override
|
public void editFuzzyMatrix(Integer expertId, String hierarchyPath, CompareMatrix matrix) {
|
// 校验矩阵
|
CompareMatrixProcessor.validate(matrix);
|
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
|
var compareMatrixMap = expert.getCompareMatrixMap();
|
if(compareMatrixMap == null) {
|
compareMatrixMap = new TreeMap<>();
|
expert.setCompareMatrixMap(compareMatrixMap);
|
}
|
compareMatrixMap.put(hierarchyPath, matrix);
|
save(expert);
|
}
|
|
@Override
|
public TreeNode<NullType> getNullModelTree(Integer expertId) {
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
var modelTree = getModelTree(expert.getModel());
|
return TreeHelper.<HierarchyData, NullType> convertTree(modelTree.root(), (node, newNode) -> null);
|
}
|
|
// public abstract TreeRoot<HierarchyData> getModelTree(Model model);
|
|
@Override
|
public TreeRoot<HierarchyData> getHierarchyTree(Integer expertId) {
|
var expert = get(expertId);
|
BizResultCode.BIZ_EXPERT_NOT_EXIST.check(expert == null);
|
|
// 首先获得模型中的树结构
|
var modelTree = getModelTree(expert.getModel());
|
|
var scoreMatrix = expert.getWeightMap();
|
// 然后根据专家的评分表，更新树的评分
|
if(scoreMatrix != null) {
|
TreeHelper.travel(modelTree.root(), (node) -> {
|
var score = scoreMatrix.get(node.getPath());
|
if (score != null) {
|
node.getData().setScore(score);
|
}
|
});
|
}
|
return modelTree;
|
}
|
|
////// 初始化专家 //////
|
@Override
|
public T add(User creator, T entity) {
|
BizResultCode.EXPERT_FUNCTIONS_MUST_ENABLE.check(CollectionUtils.isEmpty(entity.getExpertFuncs()));
|
BizResultCode.EXPERT_MODEL_NOT_EXIST.check(entity.getModel() == null || !existModel(entity.getModel().getId()));
|
if(entity.getMembershipMatrix() == null)
|
entity.setMembershipMatrix(loadDefaultMembershipMatrix());
|
return super.add(creator, entity);
|
}
|
|
@Override
|
public T edit(T entity) {
|
BizResultCode.EXPERT_FUNCTIONS_MUST_ENABLE.check(CollectionUtils.isEmpty(entity.getExpertFuncs()));
|
return super.edit(entity);
|
}
|
|
private MembershipMatrix loadDefaultMembershipMatrix() {
|
try {
|
var res = new ClassPathResource("data/membership_matrix.xlsx");
|
return new MembershipMatrixProcessor().loadFromWorkbook(res.getInputStream());
|
} catch (IOException e) {
|
throw new RuntimeException(e);
|
}
|
}
|
|
protected abstract boolean existModel(Integer modelId);
|
|
}
|
