ReliabilitySimulation.git

			@@ -1,12 +1,22 @@
			package com.zt.life.modules.mainPart.taskReliability.service;

			import com.zt.common.service.BaseService;
			import com.zt.life.modules.mainPart.taskReliability.dao.TaskDao;
			import com.zt.life.modules.mainPart.taskReliability.model.Task;
			import com.zt.life.modules.mainPart.basicInfo.dao.ParamDataDao;
			import com.zt.life.modules.mainPart.basicInfo.dao.XhProductModelDao;
			import com.zt.life.modules.mainPart.basicInfo.model.ParamData;
			import com.zt.life.modules.mainPart.basicInfo.model.XhProductModel;
			import com.zt.life.modules.mainPart.taskReliability.dao.*;
			import com.zt.life.modules.mainPart.taskReliability.dto.TaskModelCheckResult;
			import com.zt.life.modules.mainPart.taskReliability.model.*;
			import org.springframework.beans.factory.annotation.Autowired;
			import org.springframework.stereotype.Service;
			import com.zt.common.db.query.QueryFilter;

			import java.util.ArrayList;
			import java.util.HashMap;
			import java.util.List;
			import java.util.Map;
			import java.util.stream.Collectors;


			/**
			@@ -17,6 +27,19 @@
			*/
			@Service
			public class TaskService extends BaseService<TaskDao, Task> {

			@Autowired
			private OperatConditModelDao operatConditModelDao;
			@Autowired
			private ModelNodeAlgorithmDao modelNodeAlgorithmDao;
			@Autowired
			private ModelRbdDao modelRbdDao;
			@Autowired
			private XhProductModelDao xhProductModelDao;
			@Autowired
			private ParamDataDao paramDataDao;
			@Autowired
			private TaskBinoParamDao taskBinoParamDao;

			/**
			* 分页查询
			@@ -40,4 +63,182 @@
			public List<Task> getTaskList(Long productId) {
			return baseDao.getTaskList(productId);
			}

			/**
			* 对任务可靠性模型及其参数配置进行完整性检查，并指出以下5类错误：
			* 0）任务总时长未配置
			* 1）阶段时长未配置
			* 2）工况时长未配置
			* 3）工况模型树不完整
			* 4）建模未完成
			* 5）设备参数未配置
			* 可以对所有任务模型进行检查，也可以只检查入参指定的产品节点下的任务模型；前者适合在页面列表显示全体建模状态，后者适合对某任务进行仿真时的检查。
			* @param productId 产品节点ID（一般为总体）
			* @return 检查出的错误的List，长度为0表示没有错误，不会返回null
			*/
			public List<TaskModelCheckResult> checkTaskModel(Long productId, Long taskModelId) {
			List<TaskModelCheckResult> checkResult = new ArrayList<>();
			List<XhProductModel> deviceUsedList = new ArrayList<>(); // 检查对象模型中使用到的所有设备

			// 1. 获取数据
			// 1.1 获取所有任务模型数据List
			List<Task> taskModelList = baseDao.getTaskModels(productId, taskModelId);
			// 1.2 获取所有任务模型阶段数据List
			List<TaskPhase> taskModelPhaseList = baseDao.getTaskModelPhases(productId, taskModelId);
			// 1.3 获取所有任务模型工况数据List
			List<TaskPhaseModel> taskModelPhaseModelList = baseDao.getTaskModelPhaseModels(productId, taskModelId);
			// 1.4 获取产品结构树结构数据
			List<XhProductModel> productTreeList = xhProductModelDao.getProductTree(productId);
			// 1.5 获取所有模型包含的节点数据
			List<ModelNodeAlgorithm> rbdNodeList = modelNodeAlgorithmDao.getRbdNodes();
			// 1.6 获取所有工况模型树数据List
			List<OperatConditModel> gkModelList = operatConditModelDao.getGKModelTrees(productId);
			// 1.7 获取所有RBD数据List
			Map<String, Object> mapFilter = new HashMap<>();
			mapFilter.put("productId", productId);
			List<ModelRbd> modelRbdList = modelRbdDao.getList(mapFilter);
			// 1.8 获取所有设备参数（含任务模型的二项分布参数）List
			List<ParamData> paramDataList = paramDataDao.getDeviceParams(productId);
			List<TaskBinoParam> binoParamList = taskBinoParamDao.getBinoParams(taskModelId);

			// 2. 检查每个任务模型的数据完整性（递归）
			for (Task taskModel : taskModelList) {
			if (null == taskModel.getTaskDuration() \|\| 0.0 == taskModel.getTaskDuration()) {
			// 2.1 任务总时长未配置
			setTaskModelCheckResult(taskModel,
			null,
			null, null, null,
			TaskModelCheckResult.CATEGORY_TASK_TIME, checkResult);
			}
			List<TaskPhase> phases = taskModelPhaseList.stream().filter(item ->
			taskModel.getId().equals(item.getTaskId())).collect(Collectors.toList());
			for (TaskPhase phase : phases) {
			if (null == phase.getPhaseDurationRate() \|\| 0.0 == phase.getPhaseDurationRate()) {
			// 2.2 阶段时长未配置
			setTaskModelCheckResult(taskModel,
			phase,
			null, null, null,
			TaskModelCheckResult.CATEGORY_PHASE_TIME, checkResult);
			}
			List<TaskPhaseModel> phaseModels = taskModelPhaseModelList.stream().filter(item ->
			phase.getId().equals(item.getPhaseId())).collect(Collectors.toList());
			if (phaseModels.size() <= 0) {
			// 无工况模型数据
			// 2.3 工况时长未配置
			setTaskModelCheckResult(taskModel,
			phase,
			null, null, null,
			TaskModelCheckResult.CATEGORY_GK_TIME, checkResult);
			} else {
			// 有工况模型数据
			List<TaskPhaseModel> phaseModelWithDurations = taskModelPhaseModelList.stream().filter(item ->
			0.0 != item.getOperatConditDurationRate()).collect(Collectors.toList());
			if (phaseModelWithDurations.size() <= 0) {
			// 无工况模型被选用
			// 2.3 工况时长未配置
			for (TaskPhaseModel taskPhaseModel : phaseModels) {
			setTaskModelCheckResult(taskModel,
			phase,
			taskPhaseModel,
			null, null,
			TaskModelCheckResult.CATEGORY_GK_TIME, checkResult);
			}
			} else {
			// 有工况模型被选用，检查选用的工况模型
			for (TaskPhaseModel taskPhaseModel : phaseModelWithDurations) {
			// 首先找到顶层模型
			List<OperatConditModel> gkModelTops = gkModelList.stream().filter(item ->
			taskPhaseModel.getOperatConditId().equals(item.getOperatConditId())
			&& taskModel.getProductId().equals(item.getProductId())).collect(Collectors.toList());
			if (gkModelTops.size() <= 0) {
			// 无工况模型树根节点，即意味着无工况模型树
			XhProductModel node = (XhProductModel) productTreeList.stream().filter(item ->
			taskModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
			setTaskModelCheckResult(taskModel,
			phase,
			taskPhaseModel,
			null,
			node,
			TaskModelCheckResult.CATEGORY_GK_MODEL, checkResult);
			} else {
			// 有工况模型树，检查其完整性
			// checkGkModel(taskModel, phase, taskPhaseModel, gkModelTops.get(0),
			// deviceUsedList, checkResult);
			}
			}
			}
			}

			}
			}
			// 3. 返回检查结果
			return checkResult;

			}

			// 递归函数
			private void checkGkModel(Task taskModel,
			TaskPhase phase,
			TaskPhaseModel taskPhaseModel,
			OperatConditModel gkModelTreeTop,
			List<OperatConditModel> gkModelList,
			List<ModelNodeAlgorithm> rbdNodeList,
			List<XhProductModel> productTreeList,
			List<XhProductModel> deviceUsedList,
			List<TaskModelCheckResult> checkResult) {
			// 首先找到顶层模型
			List<OperatConditModel> gkModelTops = gkModelList.stream().filter(item ->
			taskPhaseModel.getOperatConditId().equals(item.getOperatConditId())
			&& taskModel.getProductId().equals(item.getProductId())).collect(Collectors.toList());
			if (gkModelTops.size() <= 0) {
			// 工况模型树不完整（顶层节点未配置模型）
			XhProductModel node = (XhProductModel) productTreeList.stream().filter(item ->
			taskModel.getProductId().equals(item.getId())).collect(Collectors.toList()).get(0);
			setTaskModelCheckResult(taskModel,
			phase,
			taskPhaseModel,
			null,
			node,
			TaskModelCheckResult.CATEGORY_GK_MODEL, checkResult);
			}
			}

			private void setTaskModelCheckResult(Task taskModel,
			TaskPhase taskModelPhase,
			TaskPhaseModel taskModelPhaseModel,
			OperatConditModel gkModel,
			XhProductModel node,
			String category,
			List<TaskModelCheckResult> checkResult) {
			TaskModelCheckResult result = new TaskModelCheckResult();
			result.setCategory(category);
			result.setProductId(taskModel.getProductId());
			result.setTaskModelId(taskModel.getId());
			result.setTaskModelName(taskModel.getTaskName());
			switch(category) {
			case TaskModelCheckResult.CATEGORY_TASK_TIME:
			break;
			case TaskModelCheckResult.CATEGORY_PHASE_TIME:
			result.setTaskModelPhaseId(taskModelPhase.getId());
			result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
			break;
			case TaskModelCheckResult.CATEGORY_GK_TIME:
			result.setTaskModelPhaseId(taskModelPhase.getId());
			result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
			if (null != taskModelPhaseModel) {
			result.setGkId(taskModelPhaseModel.getOperatConditId());
			result.setGkName(taskModelPhaseModel.getOperatConditName());
			}
			break;
			case TaskModelCheckResult.CATEGORY_GK_MODEL:
			result.setTaskModelPhaseId(taskModelPhase.getId());
			result.setTaskModelPhaseName(taskModelPhase.getPhaseName());
			result.setGkId(taskModelPhaseModel.getOperatConditId());
			result.setGkName(taskModelPhaseModel.getOperatConditName());
			result.setNodeId(node.getId());
			result.setNodeName(node.getName());
			break;
			}
			checkResult.add(result);
			}
			}