package com.ruoyi.buss.controller;
|
|
import com.alibaba.fastjson2.JSONObject;
|
import com.ruoyi.buss.common.AssessUtil;
|
import com.ruoyi.buss.common.NumberUtils;
|
import com.ruoyi.buss.domain.*;
|
import com.ruoyi.buss.domain.dto.TaskQueryParam;
|
import com.ruoyi.buss.domain.vo.TaskAssess;
|
import com.ruoyi.buss.domain.vo.TaskAssessHis;
|
import com.ruoyi.buss.service.*;
|
import com.ruoyi.common.core.controller.BaseController;
|
import com.ruoyi.common.core.domain.AjaxResult;
|
import io.swagger.v3.oas.annotations.Operation;
|
import io.swagger.v3.oas.annotations.Parameter;
|
import io.swagger.v3.oas.annotations.tags.Tag;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.web.bind.annotation.*;
|
|
import javax.script.Invocable;
|
import javax.script.ScriptEngine;
|
import javax.script.ScriptEngineManager;
|
import java.util.*;
|
import java.util.concurrent.atomic.AtomicReference;
|
import java.util.stream.Collectors;
|
|
@Tag(name = "能效评估接口")
|
@RestController
|
@RequestMapping("/buss/assess/ex")
|
public class DMAssessController extends BaseController {
|
|
@Autowired
|
private IDmHarbor2Service iDmHarbor2Service;
|
@Autowired
|
private IDsTaskDetailService iDsTaskDetailService;
|
@Autowired
|
private IDsTaskList2Service iDsTaskList2Service;
|
@Autowired
|
private IDsEffectAssessService dsEffectAssessService;
|
@Autowired
|
private IDsEffectAssessListService dsEffectAssessListService;
|
@Autowired
|
private IDsEffectAssessHisService dsEffectAssessHisService;
|
|
private Double OIL_PLACE_PER = 0.3;
|
private Double MAT_PLACE_PER = 0.2;
|
private Double AMMO_PLACE_PER = 0.5;
|
|
@Operation(summary = "获取能效评估列表")
|
@PostMapping("/list")
|
@ResponseBody
|
public AjaxResult assessList() {
|
List<DsEffectAssess> list = dsEffectAssessService.selectDsEffectAssessList(new DsEffectAssess());
|
if(null != list){
|
return success(list);
|
}
|
return error("获取能效评估列表失败，请重试");
|
}
|
|
@Operation(summary = "根据任务ID和部门编码获取评估详情")
|
@GetMapping("/assess/{type}/{taskId}/{deptId}")
|
@ResponseBody
|
public AjaxResult getByTaskId(@Parameter(name = "type", required = true, description = "评估类型") @PathVariable("type") String type,
|
@Parameter(name = "taskId", required = true, description = "任务ID") @PathVariable("taskId") Long taskId,
|
@Parameter(name = "deptId", required = true, description = "部门ID") @PathVariable("deptId") Long deptId) {
|
DsEffectAssess assess = new DsEffectAssess();
|
assess.setTaskId(taskId);
|
assess.setDeptId(deptId);
|
List<DsEffectAssess> assessList = dsEffectAssessService.selectDsEffectAssessList(assess);
|
if(null != assessList && assessList.size() > 0){
|
DsEffectAssess dsEffectAssess = assessList.get(0);
|
DsEffectAssessHis assessHis = new DsEffectAssessHis();
|
assessHis.setTaskId(taskId);
|
assessHis.setDeptId(deptId);
|
assessHis.setTYPE(type);
|
List<DsEffectAssessHis> hisList = dsEffectAssessHisService.selectDsEffectAssessHisList(assessHis);
|
TaskAssessHis taskAssess = new TaskAssessHis();
|
taskAssess.setList(hisList);
|
taskAssess.setAssess(dsEffectAssess);
|
|
return success(taskAssess);
|
}
|
else{
|
return calcDsEffectByTime(taskId, type);
|
}
|
}
|
|
@Operation(summary = "实时-根据任务ID获取评估详情")
|
@GetMapping("/assess/time/{type}/{taskid}")
|
@ResponseBody
|
public AjaxResult getTime(@Parameter(name = "type", required = true, description = "评估类型") @PathVariable("type") String type,
|
@Parameter(name = "taskid", required = true, description = "任务ID") @PathVariable("taskid") Long taskid) {
|
if(!type.equalsIgnoreCase("JD") && !type.equalsIgnoreCase("ZD")){
|
return error("获取评估类型错误，请检查参数");
|
}
|
|
return calcDsEffectByTime(taskid, type);
|
}
|
|
// 实时计算评估值
|
private AjaxResult calcDsEffectByTime(Long taskid, String type){
|
|
DsEffectAssessList assessList = new DsEffectAssessList();
|
assessList.setTYPE(type);
|
List<DsEffectAssessList> weightList = dsEffectAssessListService.selectDsEffectAssessListList(assessList);
|
|
List<DsTaskDetail> detailList = iDsTaskDetailService.selectDsTaskDetailByTaskId(taskid, null);
|
TaskQueryParam taskQueryParam = new TaskQueryParam();
|
if(null != taskid){taskQueryParam.setTaskId(taskid);}
|
List<DsTaskList2> taskList2List = iDsTaskList2Service.selectDsTaskListByParam(taskQueryParam);
|
List<DmHarbor2> harbor2List = iDmHarbor2Service.selectDmHarborList(new DmHarbor2());
|
|
List<DsEffectAssessList> dsEffectAssessLists = calcDsEffect(detailList, taskList2List, harbor2List);
|
// 更新权重指标或者是数值
|
dsEffectAssessLists = updateWeight(dsEffectAssessLists, weightList);
|
|
List<DsEffectAssessHis> hisList = covertToHis(dsEffectAssessLists, taskid);
|
dsEffectAssessHisService.updateEffectAssessHisList(hisList);
|
|
// 计算最终评估结果
|
double score = getScore(dsEffectAssessLists);
|
DsEffectAssess dsEffectAssess = new DsEffectAssess(taskid, score);
|
dsEffectAssess.setCreateTime(new Date());
|
dsEffectAssess.setCreateBy(getUsername());
|
dsEffectAssess.setDeptId(getDeptId());
|
// 保存评估结果
|
dsEffectAssessService.updateOrInsertDsEffectAssess(dsEffectAssess);
|
|
|
TaskAssess assess = new TaskAssess();
|
assess.setList(dsEffectAssessLists);
|
assess.setAssess(dsEffectAssess);
|
if(null != dsEffectAssessLists){
|
return success(assess);
|
}
|
|
return error("获取能效评估详情失败，请重试");
|
}
|
|
// 获取评价详细值
|
private List<DsEffectAssessList> calcDsEffect(List<DsTaskDetail> detailList, List<DsTaskList2> taskList2List, List<DmHarbor2> harbor2List){
|
List<DsEffectAssessList> result = new ArrayList<>();
|
if(null != detailList && detailList.size() >0){
|
int harborCount = 0; // 港口数量
|
int berthCount = 0; // 泊位数量
|
int supplyTime = 0; // 各港口补给任务总时长
|
int allocTime = 0; // 各港口分配任务总时长
|
int supplyTimeDif = 0; // 补给和任务分配时长差额总和
|
List<Integer> maxTimeDifList = new ArrayList<>(); // 两港口最大时间差
|
|
int shipSupplyTime = 0; //舰艇补给时间总和
|
int shipAllocTime = 0; // 舰艇停泊时间总和
|
|
int allTime = 0; // 任务总时长
|
int workTime = 0; // 累计补给时间总计
|
int stopTime = 0; // 累计停靠时间
|
int oilTime = 0; // 油料补给总时长
|
int matTime = 0; // 物资补给总时长
|
int ammoTime = 0; // 弹药补给总时长
|
|
double platMaxPer = 0.0; // 场地占用最大值总和
|
int platHalfTime = 0; // 泊位占用过半时间
|
int posAreaNotSameCount = 0;
|
|
Map<Long, List<DsTaskDetail>> groupedTaskList = detailList.stream()
|
.collect(Collectors.groupingBy(DsTaskDetail::getHarborId));
|
|
Set<Long> harborIds = new HashSet<>();
|
Set<Long> berthIds = new HashSet<>();
|
|
AtomicReference<Double> carTotalCountRef = new AtomicReference<>(0.0); // 各泊位物资车次总值
|
|
for (Map.Entry<Long, List<DsTaskDetail>> entry : groupedTaskList.entrySet()) {
|
|
harborIds.add(entry.getKey());
|
|
Map<Long, List<DsTaskDetail>> groupedBerthTaskList = detailList.stream()
|
.collect(Collectors.groupingBy(DsTaskDetail::getBerthId));
|
|
int maxHarborTime = 0; // 泊位最大时长
|
int allocHarborTime = 0; //s
|
for (Map.Entry<Long, List<DsTaskDetail>> berthEntry : groupedBerthTaskList.entrySet()) {
|
berthIds.add(berthEntry.getKey());
|
|
int maxOilTime = berthEntry.getValue().stream()
|
.mapToInt(DsTaskDetail::getOilTime)
|
.max()
|
.orElse(0);
|
int maxMatTime = berthEntry.getValue().stream()
|
.mapToInt(DsTaskDetail::getMatTime)
|
.max()
|
.orElse(0);
|
int maxAmmoTime = berthEntry.getValue().stream()
|
.mapToInt(DsTaskDetail::getAmmoTime)
|
.max()
|
.orElse(0);
|
|
berthEntry.getValue().stream().forEach(item -> {
|
int matTmpTime = item.getMatTime();
|
int totalCount = 0;
|
if(null != item.getFood()){
|
totalCount += item.getFood();
|
}
|
if(null != item.getFoodW()){
|
totalCount += item.getFoodW();
|
}
|
if(null != item.getFoodO()){
|
totalCount += item.getFoodO();
|
}
|
|
if(matTmpTime <= 24) {
|
int finalTotalCount = totalCount;
|
carTotalCountRef.updateAndGet(v -> (v + finalTotalCount));
|
}
|
else{
|
int finalTotalCount1 = totalCount;
|
carTotalCountRef.updateAndGet(v -> (v +
|
NumberUtils.roundToTwoDecimalPlaces(finalTotalCount1 / matTmpTime * 24)));
|
}
|
});
|
|
int maxTime = Math.max(Math.max(maxOilTime, maxMatTime), maxAmmoTime);
|
oilTime += maxOilTime;
|
matTime += maxMatTime;
|
ammoTime += maxAmmoTime;
|
if(maxTime > maxHarborTime){maxHarborTime = maxTime;}
|
supplyTime += maxTime;
|
allocHarborTime += maxTime;
|
if(allTime < maxTime) {allTime = maxTime;}
|
|
platMaxPer += getMaxPlat(berthEntry.getValue());
|
platHalfTime += getPlatHalfTime(berthEntry.getValue());
|
}
|
allocTime += groupedBerthTaskList.size() * maxHarborTime;
|
supplyTimeDif += (allocTime - allocHarborTime);
|
maxTimeDifList.add(maxHarborTime);
|
}
|
|
for (DsTaskDetail detail : detailList) {
|
// 分配时间
|
int maxTime = Math.max(Math.max(NumberUtils.getOrDefault(detail.getAmmoEtime(), 0) ,
|
NumberUtils.getOrDefault(detail.getOilEtime(), 0)), NumberUtils.getOrDefault(detail.getMatEtime(), 0));
|
// 补给时间
|
int tApplyTime = 0;
|
// 补给时间
|
if(null != detail.getSupplySeq() && (detail.getSupplySeq().equals("2") || detail.getSupplySeq().equals("3"))) {
|
// 如果为先油后弹则两个时间相加
|
tApplyTime = (detail.getAmmoTime() == null ? 0 : detail.getAmmoTime())+ (null == detail.getOilTime() ? 0 : detail.getOilTime());
|
if(tApplyTime < detail.getMatTime()){
|
tApplyTime = detail.getMatTime();
|
}
|
}
|
else{
|
// 同时补充 选择最大值
|
tApplyTime = Math.max(Math.max(Math.max(NumberUtils.getOrDefault(detail.getAmmoTime(), 0),
|
NumberUtils.getOrDefault(detail.getMatTime(), 0)), NumberUtils.getOrDefault(detail.getOilTime(), 0)),
|
NumberUtils.getOrDefault(detail.getWaterTime(), 0));
|
}
|
shipSupplyTime += tApplyTime;
|
shipAllocTime += maxTime;
|
|
if(!isShipPosAreaSame(taskList2List, detail.getTaskId(), detail.getShipNo(), harbor2List)){
|
posAreaNotSameCount++;
|
}
|
}
|
|
workTime = oilTime + matTime;
|
harborCount = harborIds.size();
|
berthCount = berthIds.size();
|
|
int maxMinTimeDif = 0;
|
// 各港口补给作业最终结束两两时间差的最大值A3
|
if (!maxTimeDifList.isEmpty()) {
|
int maxTimeDif = maxTimeDifList.stream().mapToInt(Integer::intValue).max().orElse(0);
|
int minTimeDif = maxTimeDifList.stream().mapToInt(Integer::intValue).min().orElse(0);
|
maxMinTimeDif = maxTimeDif - minTimeDif;
|
// 这里可以根据需要使用 maxMinTimeDif 变量
|
}
|
|
// 本批次舰艇数量
|
int shipCount = detailList.size(); // 本批次船数量
|
double days = NumberUtils.roundToTwoDecimalPlaces((double) allTime / 24); // 总批次补给天数
|
double carTotalCount = carTotalCountRef.get(); // 各泊位物资车次总值
|
|
// 补给方案 -- 批次总补给数量
|
double harborShipCountPercent = NumberUtils.roundToTwoDecimalPlaces(AssessUtil.getPercentForShipCount(shipCount));
|
// 补给方案 -- 批次单舰折叠补给时间
|
double harborShipEmptyPercent = NumberUtils.roundToTwoDecimalPlaces(AssessUtil.getPercentForShipEmpty(supplyTimeDif/ shipCount));
|
// 补给方案 -- 各港口结束最大时间差
|
double harborEndTimeAvgPercent = NumberUtils.roundToTwoDecimalPlaces(AssessUtil.getPercentForHarborTimeDif(maxMinTimeDif));
|
// 补给方案 -- 最大时间差占总时间比
|
double harborMaxDifPercent = NumberUtils.roundToTwoDecimalPlaces( 1 - (double)maxMinTimeDif / allTime );
|
// 补给方案 -- 本批次跨区调度舰船数
|
double harborZoomDifPercent = NumberUtils.roundToTwoDecimalPlaces(1 - (double)posAreaNotSameCount / shipCount);
|
// 补给方案 -- 各港口结束时间差 0.4 开始时间 结束时间
|
// double harborAvgTimePercent = NumberUtils.roundToTwoDecimalPlaces(1-(double)(allocTime - supplyTime)/allocTime);
|
// // 补给方案 -- 港口时间差占比均值 每个港口 补给时间 开始结束时间差
|
// double harborTimePercent = NumberUtils.roundToTwoDecimalPlaces(1- (double)supplyTime / allocTime);
|
|
// 受补舰船 -- 单舰平均停靠时间
|
double applyShipAvgStopTimePercent = NumberUtils.roundToTwoDecimalPlaces(AssessUtil.getPercentForShipStopTime(supplyTime / shipCount));
|
// 受补舰船 -- 补给作业时间均值
|
double applyShipWorkTimePercent = NumberUtils.roundToTwoDecimalPlaces(AssessUtil.getPercentForApplyTime(supplyTime / shipCount));
|
// 受补舰船 -- 补给非作业时间均值
|
double applyShipWorkNoTimePercent = NumberUtils.roundToTwoDecimalPlaces(AssessUtil.getPercentForNotApplyTime(supplyTimeDif/ shipCount));
|
// 受补舰船 -- 补给作业停泊比例 0.2 所有船补给总和 所有船占用时长
|
double shipStopPercent = NumberUtils.roundToTwoDecimalPlaces((double)shipSupplyTime/shipAllocTime);
|
// 受补舰船 -- 补给时间折叠比例 最大开始-结束时间 所有船补给时间总和
|
double shipEmptyPercent = NumberUtils.roundToTwoDecimalPlaces(1 - (double)(shipSupplyTime/detailList.size()) / allTime);
|
|
|
// 补给兵力 -- 水保日作业时间比 0.2 默认值 1 （不计算）
|
double applyWaterPercent = 1;
|
// 补给兵力 -- 油保日作业时间比 加油总时长/泊位数/停靠总时长
|
double applyOilPercent = NumberUtils.roundToTwoDecimalPlaces((double)oilTime / berthCount / allTime );
|
// 补给兵力 -- 物资日作业时间比 加油总时长/泊位数/停靠总时长
|
double applyMatPercent = NumberUtils.roundToTwoDecimalPlaces((double)matTime / allocTime);
|
|
|
// 补给设施 -- 泊位日均周转艘次
|
double facBerthPercent = NumberUtils.roundToTwoDecimalPlaces(
|
AssessUtil.getPercentForBerthTime( NumberUtils.roundToTwoDecimalPlaces(shipCount / days / berthCount )));
|
// 补给设施 -- 前沿占地最大均值 0.2
|
double facPartPercent = NumberUtils.roundToTwoDecimalPlaces(platMaxPer / berthCount / 1.5);
|
if(facPartPercent > 1) facPartPercent = 1.0;
|
// 补给设施 -- 前沿占半时长均值
|
double facPartTimePercent = NumberUtils.roundToTwoDecimalPlaces(AssessUtil.getPercentForBerthHoldTime((double) platHalfTime / berthCount));
|
// 补给设施 -- 加油设施日均使用率
|
double facOilPercent = NumberUtils.roundToTwoDecimalPlaces((double)oilTime / berthCount / allTime );
|
// 补给设施 -- 各泊位物资车次均值
|
double facCarPercent = NumberUtils.roundToTwoDecimalPlaces(AssessUtil.getPercentForCar((double)carTotalCount / berthCount ));
|
|
result.add(new DsEffectAssessList("JD","A12", harborShipCountPercent, 0.1, 0.4));
|
result.add(new DsEffectAssessList("JD","A13", harborShipEmptyPercent, 0.2, 0.4));
|
result.add(new DsEffectAssessList("JD","A14", harborEndTimeAvgPercent, 0.2, 0.4));
|
result.add(new DsEffectAssessList("JD","A15", harborMaxDifPercent, 0.3, 0.4));
|
result.add(new DsEffectAssessList("JD","A16", harborZoomDifPercent, 0.2, 0.4));
|
|
result.add(new DsEffectAssessList("JD","A21", applyShipAvgStopTimePercent, 0.2, 0.2));
|
result.add(new DsEffectAssessList("JD","A22", applyShipWorkTimePercent, 0.2, 0.2));
|
result.add(new DsEffectAssessList("JD","A23", applyShipWorkNoTimePercent, 0.2, 0.2));
|
result.add(new DsEffectAssessList("JD","A24", shipStopPercent, 0.2, 0.2));
|
result.add(new DsEffectAssessList("JD","A25", shipEmptyPercent, 0.2, 0.2));
|
|
result.add(new DsEffectAssessList("JD","A31", applyWaterPercent, 0.3, 0.2));
|
result.add(new DsEffectAssessList("JD","A32", applyOilPercent, 0.4, 0.2));
|
result.add(new DsEffectAssessList("JD","A33", applyMatPercent, 0.3,0.2));
|
|
result.add(new DsEffectAssessList("JD","A41", facBerthPercent, 0.3, 0.2));
|
result.add(new DsEffectAssessList("JD","A42", facPartPercent, 0.1, 0.2));
|
result.add(new DsEffectAssessList("JD","A43", facPartTimePercent, 0.2, 0.2));
|
result.add(new DsEffectAssessList("JD","A44", facOilPercent, 0.2, 0.2));
|
result.add(new DsEffectAssessList("JD","A45", facCarPercent, 0.2, 0.2));
|
}
|
|
return result;
|
}
|
|
// 获取泊位最大场地占用
|
private Double getMaxPlat(List<DsTaskDetail> list){
|
double maxPlat = 0.0;
|
for (int i = 1; i <= 24; i++) {
|
int oilCount = 0;
|
int ammoCount = 0;
|
int matCount = 0;
|
for (DsTaskDetail task : list) {
|
if (task.getOilStime() != null && task.getOilStime() <= i && task.getOilEtime() >= i) {
|
oilCount++;
|
} else if (task.getAmmoStime() != null && task.getAmmoStime() <= i && task.getAmmoEtime() >= i) {
|
ammoCount++;
|
} else if (task.getMatStime() != null && task.getMatStime() <= i && task.getMatEtime() >= i) {
|
matCount++;
|
}
|
}
|
|
Double totalSupply = NumberUtils.roundToTwoDecimalPlaces(oilCount * OIL_PLACE_PER + ammoCount * AMMO_PLACE_PER + matCount * MAT_PLACE_PER);
|
if(maxPlat < totalSupply){
|
maxPlat = totalSupply;
|
}
|
}
|
return maxPlat;
|
}
|
|
// 获取泊位占用过半的时间
|
private Integer getPlatHalfTime(List<DsTaskDetail> list){
|
Integer platTime = 0;
|
for (int i = 1; i <= 24; i++) {
|
int oilCount = 0;
|
int ammoCount = 0;
|
int matCount = 0;
|
for (DsTaskDetail task : list) {
|
if (task.getOilStime() != null && task.getOilStime() <= i && task.getOilEtime() >= i) {
|
oilCount++;
|
} else if (task.getAmmoStime() != null && task.getAmmoStime() <= i && task.getAmmoEtime() >= i) {
|
ammoCount++;
|
} else if (task.getMatStime() != null && task.getMatStime() <= i && task.getMatEtime() >= i) {
|
matCount++;
|
}
|
}
|
Double totalSupply = NumberUtils.roundToTwoDecimalPlaces(oilCount * OIL_PLACE_PER + ammoCount * AMMO_PLACE_PER + matCount * MAT_PLACE_PER);
|
if(totalSupply >= 0.5){
|
platTime++;
|
}
|
}
|
return platTime;
|
}
|
|
// 计算最终分数
|
private Double getScore(List<DsEffectAssessList> list){
|
Double score = 0.0;
|
if(null != list && list.size() > 0){
|
Map<String, List<DsEffectAssessList>> groupedByCode = list.stream()
|
.collect(Collectors.groupingBy(item -> item.getCODE().substring(0, 2)));
|
|
for (Map.Entry<String, List<DsEffectAssessList>> berthEntry : groupedByCode.entrySet()) {
|
DsEffectAssessList effectAssess = berthEntry.getValue().get(0);
|
Double classifyWeight = null == effectAssess.getClassifyWeight()?0.0:effectAssess.getClassifyWeight();
|
|
Double totalValue = berthEntry.getValue().stream()
|
.mapToDouble(item -> item.getVal() * item.getWEIGHT())
|
.sum();
|
score += totalValue * classifyWeight;
|
}
|
}
|
return NumberUtils.roundToTwoDecimalPlaces(score * 10);
|
}
|
|
private Double getScore3(List<DsEffectAssessList> list){
|
|
ScriptEngineManager manager = new ScriptEngineManager();
|
ScriptEngine engine = manager.getEngineByName("JavaScript");
|
|
try {
|
// 构建JavaScript函数
|
String script = "function calculateScore(list) {" +
|
" var score = 0;" +
|
" if(list && list.length > 0) {" +
|
" var groupedByCode = {};" +
|
" for(var i = 0; i < list.length; i++) {" +
|
" var code = list[i].CODE.substring(0,2);" +
|
" if(!groupedByCode[code]) {" +
|
" groupedByCode[code] = [];" +
|
" }" +
|
" groupedByCode[code].push(list[i]);" +
|
" }" +
|
" for(var code in groupedByCode) {" +
|
" var items = groupedByCode[code];" +
|
" var classifyWeight = items[0].classifyWeight || 0;" +
|
" var totalValue = 0;" +
|
" for(var j = 0; j < items.length; j++) {" +
|
" totalValue += items[j].val * items[j].WEIGHT;" +
|
" }" +
|
" score += totalValue * classifyWeight;" +
|
" }" +
|
" }" +
|
" return Math.round(score * 10 * 100) / 100;" +
|
"}";
|
|
// 编译并执行脚本
|
engine.eval(script);
|
|
// 将Java对象转换为JSON
|
String jsonList = JSONObject.toJSONString(list);
|
|
// 调用JavaScript函数
|
Invocable invocable = (Invocable) engine;
|
Object result = invocable.invokeFunction("calculateScore", jsonList);
|
|
return Double.parseDouble(result.toString());
|
|
} catch (Exception e) {
|
e.printStackTrace();
|
System.out.println("计算分数失败");
|
return 0.0;
|
}
|
}
|
|
/**
|
* 根据任务ID和舷号获取对应的任务
|
* @param list
|
* @param taskid
|
* @param shipNo
|
* @return
|
*/
|
private boolean isShipPosAreaSame(List<DsTaskList2> list, Long taskid, String shipNo, List<DmHarbor2> harbor2List){
|
Optional<DsTaskList2> tmpTaskOptions = list.stream().filter(task -> task.getTaskId() == taskid && task.getShipNo().equals(shipNo)).findFirst();
|
if(!tmpTaskOptions.isEmpty()){
|
Optional<DmHarbor2> harbor2 = harbor2List.stream().filter(dmHarbor2 ->
|
dmHarbor2.getDOCKNAME().equals(tmpTaskOptions.get().getPosArea()) && tmpTaskOptions.get().getHarborId() == dmHarbor2.getPKID()).findFirst();
|
if(!harbor2.isEmpty()){
|
return true;
|
}
|
}
|
return false;
|
}
|
|
private DsEffectAssessHis covertToHis(DsEffectAssessList assessList, Long taskId){
|
DsEffectAssessHis his = null;
|
if(null != assessList){
|
his = new DsEffectAssessHis();
|
his.setClassifyIndex(assessList.getClassifyIndex());
|
his.setCODE(assessList.getCODE());
|
his.setClassifyWeight(assessList.getClassifyWeight());
|
his.setITEM(assessList.getITEM());
|
his.setDeptId(assessList.getDeptId());
|
his.setItemDetail(assessList.getItemDetail());
|
his.setNORMAL(assessList.getNORMAL());
|
his.setPLAN(assessList.getPLAN());
|
his.setTaskId(assessList.getAssessId());
|
his.setTYPE(assessList.getTYPE());
|
his.setWEIGHT(assessList.getWEIGHT());
|
his.setUNIT(assessList.getUNIT());
|
his.setCreateBy(assessList.getCreateBy());
|
his.setCreateTime(new Date());
|
his.setVal(assessList.getVal());
|
his.setTaskId(taskId);
|
}
|
return his;
|
}
|
|
private List<DsEffectAssessHis> covertToHis(List<DsEffectAssessList> assessLists, Long taskId){
|
List<DsEffectAssessHis> list = new ArrayList<>();
|
for(DsEffectAssessList tmp : assessLists){
|
list.add(this.covertToHis(tmp, taskId));
|
}
|
return list;
|
}
|
|
// 更新权重值
|
private List<DsEffectAssessList> updateWeight(List<DsEffectAssessList> list, List<DsEffectAssessList> weightList){
|
Long deptId = getDeptId();
|
List<DsEffectAssessList> result = new ArrayList<>();
|
if(null != list && list.size() > 0 && null != weightList && weightList.size() > 0) {
|
for(DsEffectAssessList item : list){
|
DsEffectAssessList tmpAssess = getWeightValFromList(weightList, item);
|
if(null != tmpAssess){
|
item.setWEIGHT(tmpAssess.getWEIGHT());
|
item.setClassifyWeight(tmpAssess.getClassifyWeight());
|
item.setPLAN(tmpAssess.getPLAN());
|
item.setITEM(tmpAssess.getITEM());
|
item.setItemDetail(tmpAssess.getItemDetail());
|
item.setUNIT(tmpAssess.getUNIT());
|
item.setNORMAL(tmpAssess.getNORMAL());
|
item.setClassifyIndex(tmpAssess.getClassifyIndex());
|
item.setDeptId(deptId);
|
}
|
result.add(item);
|
}
|
}
|
return result;
|
}
|
|
// 获取对应的权重值行
|
private DsEffectAssessList getWeightValFromList(List<DsEffectAssessList> list, DsEffectAssessList dsEffectAssessList){
|
for (DsEffectAssessList assessList : list ){
|
if(assessList.getTYPE().equals(dsEffectAssessList.getTYPE()) && assessList.getCODE().equals(dsEffectAssessList.getCODE())){
|
return assessList;
|
}
|
}
|
return null;
|
}
|
|
}
|
