ansteel-biz/src/main/java/com/iailab/module/ansteel/api/controller/admin/PowerController.java

@@ -1,22 +1,21 @@
package com.iailab.module.ansteel.api.controller.admin;

import cn.hutool.core.util.NumberUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.iailab.framework.common.exception.enums.GlobalErrorCodeConstants;
import com.iailab.framework.common.pojo.CommonResult;
import com.iailab.framework.common.pojo.PageResult;
import com.iailab.framework.common.util.date.DateUtils;
import com.iailab.framework.common.util.object.BeanUtils;
import com.iailab.framework.common.util.object.ConvertUtils;
import com.iailab.framework.tenant.core.context.TenantContextHolder;
import com.iailab.module.ansteel.api.dto.*;
import com.iailab.module.ansteel.api.vo.PowerCapacitorHisPageReqVO;
import com.iailab.module.ansteel.api.vo.PowerMaxDemandMainPageReqVO;
import com.iailab.module.ansteel.common.constant.CommonConstant;
import com.iailab.module.ansteel.common.enums.ProcessConfDataTypeEnum;
import com.iailab.module.ansteel.common.enums.TransferTypeEnum;
import com.iailab.module.ansteel.common.utils.DecimalUtil;
import com.iailab.module.ansteel.job.dto.ScheduleJobDTO;
import com.iailab.module.ansteel.job.entity.ScheduleJobEntity;
import com.iailab.module.ansteel.job.service.ScheduleJobService;
import com.iailab.module.ansteel.job.vo.ScheduleJobReqVO;
import com.iailab.module.ansteel.common.utils.PowerUtil;
import com.iailab.module.ansteel.power.entity.*;
import com.iailab.module.ansteel.power.service.*;
import com.iailab.module.data.api.point.DataPointApi;
@@ -24,20 +23,26 @@
import com.iailab.module.data.api.point.dto.ApiPointValueQueryDTO;
import com.iailab.module.data.api.point.dto.ApiPointsValueQueryDTO;
import com.iailab.module.model.api.mcs.McsApi;
import com.iailab.module.model.api.mcs.dto.ChartParamDTO;
import com.iailab.module.model.api.mcs.dto.PredictLastValueReqVO;
import com.iailab.module.model.api.mdk.MdkApi;
import com.iailab.module.model.api.mdk.dto.MdkScheduleReqDTO;
import com.iailab.module.model.api.mdk.dto.MdkScheduleRespDTO;
import io.swagger.v3.oas.annotations.Operation;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.util.CollectionUtils;
import org.springframework.validation.annotation.Validated;
import org.springframework.util.ObjectUtils;
import org.springframework.web.bind.annotation.*;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

import static com.iailab.framework.common.pojo.CommonResult.error;
import static com.iailab.framework.common.pojo.CommonResult.success;

/**
@@ -80,6 +85,9 @@
    private McsApi mcsApi;

    @Autowired
    private MdkApi mdkApi;

    @Autowired
    private PowerCapacitorHisService powerCapacitorHisService;

    @Autowired
@@ -93,8 +101,21 @@

    @Autowired
    private PowerMaxdemandMainService powerMaxDemandMainService;

    @Autowired
    private PowerMaxdemandDetService powerMaxdemandDetService;

    @Autowired
    private PowerPriceMainService powerPriceMainService;

    @Autowired
    private PowerFactorControlService powerFactorControlService;

    public static final String VALUE = "value";

    public static final String TIME = "time";

    private String pointNo = "F0000201825";

    @GetMapping("/net-factor/list")
    @Operation(summary = "功率因数-电网拓扑")
@@ -231,6 +252,32 @@
                    powerNetFactorDTO.setQstatus(1);
                }
            }

            // 日功率因数
            if (StringUtils.isNotBlank(entity.getPDay()) && StringUtils.isNotBlank(entity.getQDay())) {
                List<String> pointNos = new ArrayList<>();
                pointNos.add(entity.getPDay());
                pointNos.add(entity.getQDay());
                Map<String, Object> pointsRealValue = dataPointApi.queryPointsRealValue(pointNos);
                if (!CollectionUtils.isEmpty(pointsRealValue)) {
                    double pValue = new BigDecimal(pointsRealValue.get(entity.getPDay()).toString()).doubleValue();
                    double qValue = new BigDecimal(pointsRealValue.get(entity.getQDay()).toString()).doubleValue();
                    powerNetFactorDTO.setDayCos(new BigDecimal(PowerUtil.calculateCos(pValue, qValue)).setScale(2, BigDecimal.ROUND_HALF_UP));
                }
            }

            // 月功率因数
            if (StringUtils.isNotBlank(entity.getPMon()) && StringUtils.isNotBlank(entity.getQMon())) {
                List<String> pointNos = new ArrayList<>();
                pointNos.add(entity.getPMon());
                pointNos.add(entity.getQMon());
                Map<String, Object> pointsRealValue = dataPointApi.queryPointsRealValue(pointNos);
                if (!CollectionUtils.isEmpty(pointsRealValue)) {
                    double pValue = new BigDecimal(pointsRealValue.get(entity.getPMon()).toString()).doubleValue();
                    double qValue = new BigDecimal(pointsRealValue.get(entity.getQMon()).toString()).doubleValue();
                    powerNetFactorDTO.setMonthCos(new BigDecimal(PowerUtil.calculateCos(pValue, qValue)).setScale(2, BigDecimal.ROUND_HALF_UP));
                }
            }
            result.add(powerNetFactorDTO);
        }
        return success(result);
@@ -327,28 +374,41 @@
    @GetMapping("/gen-status/list")
    @Operation(summary = "功率因数-发电机组实时状态")
    public CommonResult<List<PowerGenStatusDTO>> getPowerGenStatusList(@RequestParam Map<String, Object> params) {
        List<PowerGenStatusDTO> result = new ArrayList<>();
        List<PowerGenStatusEntity> list = powerGenStatusDaoService.list(params);
        List<PowerGenStatusDTO> result = ConvertUtils.sourceToTarget(list, PowerGenStatusDTO.class);
        if (CollectionUtils.isEmpty(result)) {
        if (CollectionUtils.isEmpty(list)) {
            return success(result);
        }
        for (PowerGenStatusDTO dto : result) {
        for (PowerGenStatusEntity entity : list) {
            PowerGenStatusDTO dto = new PowerGenStatusDTO();
            dto.setId(entity.getId());
            dto.setName(entity.getName());
            dto.setSort(entity.getSort());

            List<String> points = new ArrayList<>();
            if (StringUtils.isNotBlank(dto.getCurP())) {
                points.add(dto.getCurP());
            if (StringUtils.isNotBlank(entity.getCurP())) {
                points.add(entity.getCurP());
            }
            if (StringUtils.isNotBlank(dto.getCurQ())) {
                points.add(dto.getCurQ());
            if (StringUtils.isNotBlank(entity.getCurQ())) {
                points.add(entity.getCurQ());
            }
            if (StringUtils.isNotBlank(entity.getCurCos())) {
                points.add(entity.getCurCos());
            }
            if (!CollectionUtils.isEmpty(points)) {
                Map<String, Object> pointsRealValue = dataPointApi.queryPointsRealValue(points);
                if (pointsRealValue.get(dto.getCurP()) != null) {
                    dto.setCurP(pointsRealValue.get(dto.getCurP()).toString());
                if (pointsRealValue.get(entity.getCurP()) != null) {
                    dto.setCurP(new BigDecimal(pointsRealValue.get(entity.getCurP()).toString()));
                }
                if (pointsRealValue.get(dto.getCurQ()) != null) {
                    dto.setCurQ(pointsRealValue.get(dto.getCurQ()).toString());
                if (pointsRealValue.get(entity.getCurQ()) != null) {
                    dto.setCurQ(new BigDecimal(pointsRealValue.get(entity.getCurQ()).toString()));
                }
                if (pointsRealValue.get(entity.getCurCos()) != null) {
                    dto.setCurCos(new BigDecimal(pointsRealValue.get(entity.getCurCos()).toString()));
                }
            }

            result.add(dto);
        }

        return success(result);
@@ -431,8 +491,53 @@
    @GetMapping("/capacitor-status/list")
    @Operation(summary = "功率因数-电容器投退状态")
    public CommonResult<List<PowerCapacitorStatusDTO>> getPowerCapacitorStatusList(@RequestParam Map<String, Object> params) {
        List<PowerCapacitorStatusDTO> result = new ArrayList<>();
        List<PowerCapacitorStatusEntity> list = powerCapacitorStatusService.list(params);
        return success(ConvertUtils.sourceToTarget(list, PowerCapacitorStatusDTO.class));
        for (PowerCapacitorStatusEntity entity : list) {
            PowerCapacitorStatusDTO dto = new PowerCapacitorStatusDTO();
            dto.setId(entity.getId());
            dto.setName(entity.getName());
            dto.setRemark(entity.getRemark());
            dto.setMainCount(DecimalUtil.toBigDecimal(entity.getMainCount()).intValue());
            dto.setChildCount(DecimalUtil.toBigDecimal(entity.getChildCount()).intValue());
            int onCount = 0;
            Map<String, Object> params1 = new HashMap<>();
            params1.put("statusId", entity.getId());
            List<PowerCapacitorDetEntity> detList = powerCapacitorDetService.list(params1);
            if (CollectionUtils.isEmpty(detList)) {
                dto.setOnCount(onCount);
                continue;
            }
            List<String> points = new ArrayList<>();
            Map<String, Object> pointsRealValue = new HashMap<>();
            for (PowerCapacitorDetEntity det : detList) {
                if (StringUtils.isNotBlank(det.getPointNo())) {
                    points.add(det.getPointNo());
                }
            }
            if (!CollectionUtils.isEmpty(points)) {
                pointsRealValue = dataPointApi.queryPointsRealValue(points);
            }
            for (PowerCapacitorDetEntity det : detList) {
                if (StringUtils.isBlank(det.getId())) {
                    continue;
                }
                Object obj = pointsRealValue.get(det.getPointNo());
                if (obj == null) {
                    continue;
                }
                BigDecimal pv = new BigDecimal(obj.toString());
                if (pv.compareTo(BigDecimal.ZERO) <= 0) {
                    continue;
                }
                onCount++;
            }
            dto.setOnCount(onCount);
            String remark = String.format("共%d台，在投%d台", DecimalUtil.toBigDecimal(entity.getMainCount()).intValue(), onCount);
            dto.setRemark(remark);
            result.add(dto);
        }
        return success(result);
    }

    @GetMapping("/capacitor-det/list")
@@ -440,10 +545,13 @@
    public CommonResult<List<PowerCapacitorDetDTO>> getPowerCapacitorDetList(@RequestParam Map<String, Object> params) {
        List<PowerCapacitorDetEntity> list = powerCapacitorDetService.list(params);
        log.info("list.size=" + list.size());
        List<String> points = list.stream().map(item -> {
            return item.getPointNo();
        }).collect(Collectors.toList());
        List<String> points = new ArrayList<>();
        Map<String, Object> pointsRealValue = new HashMap<>();
        for (PowerCapacitorDetEntity det : list) {
            if (StringUtils.isNotBlank(det.getPointNo())) {
                points.add(det.getPointNo());
            }
        }
        if (!CollectionUtils.isEmpty(points)) {
            pointsRealValue = dataPointApi.queryPointsRealValue(points);
        }
@@ -467,8 +575,30 @@
    @GetMapping("/capacitor-his/list")
    @Operation(summary = "功率因数-电容器投退历史")
    public CommonResult<List<PowerCapacitorHisDTO>> getPowerCapacitorHisList(@RequestParam Map<String, Object> params) {
        List<PowerCapacitorHisEntity> list = powerCapacitorHisService.list(params);
        String statusId = (String) params.get("statusId");
        if (StringUtils.isBlank(statusId)) {
            return success(new ArrayList<>());
        }

        List<PowerCapacitorDetEntity> detList = powerCapacitorDetService.list(statusId);
        List<String> detIds = detList.stream().map(PowerCapacitorDetEntity::getId).collect(Collectors.toList());
        List<PowerCapacitorHisEntity> list = powerCapacitorHisService.list(detIds);
        return success(ConvertUtils.sourceToTarget(list, PowerCapacitorHisDTO.class));
    }

    @PostMapping("/capacitor-his/page")
    @Operation(summary = "功率因数-电容器投退历史（分页）")
    public CommonResult<PageResult<PowerCapacitorHisDTO>> getPowerCapacitorHisPage(@RequestBody PowerCapacitorHisPageReqVO reqVO) {
        if (StringUtils.isBlank(reqVO.getStatusId())) {
            return error(GlobalErrorCodeConstants.BAD_REQUEST);
        }

        List<PowerCapacitorDetEntity> detList = powerCapacitorDetService.list(reqVO.getStatusId());
        List<String> detIds = detList.stream().map(PowerCapacitorDetEntity::getId).collect(Collectors.toList());
        reqVO.setDetIdList(detIds);

        PageResult<PowerCapacitorHisEntity> data = powerCapacitorHisService.page(reqVO);
        return success(BeanUtils.toBean(data, PowerCapacitorHisDTO.class));
    }

    @GetMapping("/control-main/list")
@@ -522,47 +652,62 @@
    @GetMapping("/demand/list")
    @Operation(summary = "负荷移植-月最大需量，实测需量，有功功率")
    public CommonResult<List<PowerDemandDTO>> getPowerDemandList(@RequestParam Map<String, Object> params) {
        log.info("负荷移植-月最大需量，实测需量，有功功率");
        List<PowerDemandDTO> result = new ArrayList<>();
        List<PowerDemandEntity> list = powerDemandService.list(params);
        List<PowerDemandDTO> result = ConvertUtils.sourceToTarget(list, PowerDemandDTO.class);
        if (CollectionUtils.isEmpty(result)) {
        if (CollectionUtils.isEmpty(list)) {
            log.info("list.size=" + list.size());
            return success(result);
        }
        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        calendar.set(Calendar.DAY_OF_MONTH, 1);
        Date start = calendar.getTime();
        Date end = new Date();

        for (PowerDemandDTO dto : result) {
        for (PowerDemandEntity entity : list) {
            PowerDemandDTO demandDTO = new PowerDemandDTO();
            demandDTO.setId(entity.getId());
            demandDTO.setCode(entity.getCode());
            demandDTO.setName(entity.getName());

            List<String> points = new ArrayList<>();
            if (StringUtils.isNotBlank(dto.getCurDemand())) {
                points.add(dto.getCurDemand());
            if (StringUtils.isNotBlank(entity.getCurDemand())) {
                points.add(entity.getCurDemand());
            }
            if (StringUtils.isNotBlank(dto.getActivePower())) {
                points.add(dto.getActivePower());
            if (StringUtils.isNotBlank(entity.getActivePower())) {
                points.add(entity.getActivePower());
            }
            if (!CollectionUtils.isEmpty(points)) {
                Map<String, Object> pointsRealValue = dataPointApi.queryPointsRealValue(points);
                if (pointsRealValue.get(dto.getCurDemand()) != null) {
                    dto.setCurDemand(pointsRealValue.get(dto.getCurDemand()).toString());
                if (pointsRealValue.get(entity.getCurDemand()) != null) {
                    demandDTO.setCurDemand(new BigDecimal(pointsRealValue.get(entity.getCurDemand()).toString()));
                }
                if (pointsRealValue.get(dto.getActivePower()) != null) {
                    dto.setActivePower(pointsRealValue.get(dto.getActivePower()).toString());
                if (pointsRealValue.get(entity.getActivePower()) != null) {
                    demandDTO.setActivePower(new BigDecimal(pointsRealValue.get(entity.getActivePower()).toString()));
                }
            }

            if (!StringUtils.isEmpty(dto.getMaxDemand())) {
                Date start = calendar.getTime();
                ApiPointValueQueryDTO apiPointValueQueryDTO = new ApiPointValueQueryDTO();
            if (!StringUtils.isEmpty(entity.getMaxDemand())) {
                /*ApiPointValueQueryDTO apiPointValueQueryDTO = new ApiPointValueQueryDTO();
                apiPointValueQueryDTO.setStart(start);
                apiPointValueQueryDTO.setPointNo(dto.getMaxDemand());
                Map<String, Object> maxValue = dataPointApi.queryPointMaxValue(apiPointValueQueryDTO);
                apiPointValueQueryDTO.setEnd(end);
                apiPointValueQueryDTO.setPointNo(entity.getMaxDemand());
                Map<String, Object> maxValue = dataPointApi.queryPointMaxTimeValue(apiPointValueQueryDTO);
                if (maxValue != null) {
                    dto.setMaxDemand(maxValue.get(dto.getMaxDemand()) == null ? "" : maxValue.get(dto.getMaxDemand()).toString());
                    demandDTO.setMaxDemand(new BigDecimal(maxValue.get(VALUE).toString()));
                    demandDTO.setOccurTime(DateUtils.parse( maxValue.get(TIME).toString(), DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND));
                }*/
                PowerMaxdemandMainEntity maxdemandMainEntity = powerMaxDemandMainService.getMonthMax(entity.getCode(), start);
                if (maxdemandMainEntity != null) {
                    demandDTO.setMaxDemand(maxdemandMainEntity.getMaxDemand());
                    demandDTO.setOccurTime(maxdemandMainEntity.getOccurTime());
                }

            }
            result.add(demandDTO);
        }
        return success(result);
    }
@@ -606,15 +751,11 @@

    @PostMapping("/demand-query/list")
    @Operation(summary = "负荷移植-需量值查询")
    public CommonResult<List<PowerDemandQueryRespDTO>> getDemandDropdownList(@RequestBody PowerDemandQueryDTO queryDto) {
    public CommonResult<List<PowerDemandQueryRespDTO>> getDemandQueryList(@RequestBody PowerDemandQueryDTO queryDto) {
        List<PowerDemandQueryRespDTO> result = new ArrayList<>();
        if (StringUtils.isBlank(queryDto.getCode())) {
            log.info("code isBlank");
            return success(result);
        }
        log.info("code=" + queryDto.getCode());
        if (StringUtils.isBlank(queryDto.getNodeCode())) {
            log.info("NodeCode isBlank");
        }
        PowerDemandEntity entity = powerDemandService.getByCode(queryDto.getCode());
        if (entity == null) {
@@ -638,91 +779,67 @@
        params0.put("groupName", entity.getName());
        List<PowerNetDropdownEntity> dropdownList = powerNetDropdownService.list(params0);
        List<String> pointNos = new ArrayList<>();
        Map<String, String> demandPointMap = new HashMap<>();
        for (PowerNetDropdownEntity netDropdown : dropdownList) {
            demandPointMap.put(netDropdown.getNodeCode(), netDropdown.getExt1());
            if (StringUtils.isNotBlank(netDropdown.getExt1())) {
                pointNos.add(netDropdown.getExt1());
            }
        }
        if (StringUtils.isBlank(queryDto.getNodeCode()) || queryDto.getCurDemand() == null) {
            log.info("查询当前值");
            Map<String, Object> pointsRealValue = new HashMap<>();
            if (!CollectionUtils.isEmpty(pointNos)) {
                pointsRealValue = dataPointApi.queryPointsRealValue(pointNos);
        for (PowerNetDropdownEntity netDropdown : dropdownList) {
            PowerDemandQueryRespDTO dto = ConvertUtils.sourceToTarget(netDropdown, PowerDemandQueryRespDTO.class);
            dto.setCurDemand(null);
            result.add(dto);
        }
        if (queryDto.getCurDemand() == null) {
            log.info("查询值为空，显示空白");
            return success(result);
        }
        ApiPointValueQueryDTO queryCodeValue = new ApiPointValueQueryDTO();
        queryCodeValue.setStart(startTime);
        queryCodeValue.setEnd(endTime);
        queryCodeValue.setPointNo(entity.getCurDemand());
        List<ApiPointValueDTO> codeValueList = dataPointApi.queryPointHistoryValue(queryCodeValue);
        if (CollectionUtils.isEmpty(codeValueList)) {
            return success(result);
        }
        ApiPointValueDTO curValue = new ApiPointValueDTO();
        for (ApiPointValueDTO valueDTO : codeValueList) {
            if (Math.abs(queryDto.getCurDemand().doubleValue() - valueDTO.getV()) <= 0.0001) {
                log.info("curValue is find");
                curValue = valueDTO;
                break;
            }
            for (PowerNetDropdownEntity netDropdown : dropdownList) {
                PowerDemandQueryRespDTO dto = ConvertUtils.sourceToTarget(netDropdown, PowerDemandQueryRespDTO.class);
                BigDecimal demand = null;
                if (pointsRealValue.get(netDropdown.getExt1()) != null) {
                    demand = new BigDecimal(pointsRealValue.get(netDropdown.getExt1()).toString());
                }
                dto.setCurDemand(demand);
                dto.setDataTime(calendar.getTime());
                result.add(dto);
            }
        } else {
            log.info("查询历史值");
            String nodeCode = queryDto.getNodeCode();
            if (StringUtils.isBlank(nodeCode)) {
                log.info("nodeCode isBlank");
                return success(result);
            }
            PowerNetDropdownEntity powerNetDropdownEntity = powerNetDropdownService.getByNodeCode(nodeCode);
            if (powerNetDropdownEntity == null) {
                log.info("PowerNetDropdownEntity is null");
                return success(result);
            }
            ApiPointsValueQueryDTO valueQueryDTO = new ApiPointsValueQueryDTO();
            valueQueryDTO.setPointNos(pointNos);
            valueQueryDTO.setStart(startTime);
            valueQueryDTO.setEnd(endTime);
            Map<String, List<Map<String, Object>>> pointsHisValues = dataPointApi.queryPointsHistoryValue(valueQueryDTO);
            if (CollectionUtils.isEmpty(pointsHisValues)) {
                log.info("pointsHisValues is null");
                return success(result);
            }
        }
        log.info("curValue={}", curValue);
        if (curValue.getT() == null) {
            log.info("curValue is not find");
            return success(result);
        }

            ApiPointValueQueryDTO pointValueQueryDTO = new ApiPointValueQueryDTO();
            pointValueQueryDTO.setStart(startTime);
            pointValueQueryDTO.setEnd(endTime);
            pointValueQueryDTO.setPointNo(powerNetDropdownEntity.getExt1());
            List<ApiPointValueDTO> hisValue = dataPointApi.queryPointHistoryValue(pointValueQueryDTO);
            if (CollectionUtils.isEmpty(hisValue)) {
                log.info("hisValue is null");
        Calendar calendar1 = Calendar.getInstance();
        calendar1.setTime(curValue.getT());
        ApiPointsValueQueryDTO valueQueryDTO = new ApiPointsValueQueryDTO();
        valueQueryDTO.setPointNos(pointNos);
        valueQueryDTO.setEnd(calendar1.getTime());
        calendar1.add(Calendar.MINUTE, -1);
        valueQueryDTO.setStart(calendar1.getTime());
        Map<String, List<Map<String, Object>>> pointsHisValues = dataPointApi.queryPointsHistoryValue(valueQueryDTO);
        if (CollectionUtils.isEmpty(pointsHisValues)) {
            log.info("pointsHisValues is null");
            return success(result);
        }
        for (PowerDemandQueryRespDTO respDTO : result) {
            if (StringUtils.isBlank(demandPointMap.get(respDTO.getNodeCode()))) {
                continue;
            }
            ApiPointValueDTO curValue = null;
            Collections.reverse(hisValue);
            for (ApiPointValueDTO valueDTO : hisValue) {
                if ((queryDto.getCurDemand().doubleValue() - valueDTO.getV()) <= 0.0001) {
                    curValue = valueDTO;
                    log.info("curValue is find");
                    break;
                }
            List<Map<String, Object>> hisList = pointsHisValues.get(demandPointMap.get(respDTO.getNodeCode()));
            if (CollectionUtils.isEmpty(hisList)) {
                continue;
            }
            if (curValue == null) {
                log.info("curValue is null");
                for (PowerNetDropdownEntity netDropdown : dropdownList) {
                    PowerDemandQueryRespDTO dto = ConvertUtils.sourceToTarget(netDropdown, PowerDemandQueryRespDTO.class);
                    if (dto.getNodeCode().equals(nodeCode)) {
                        dto.setCurDemand(queryDto.getCurDemand());
                    }
                    result.add(dto);
                }
                return success(result);
            }
            log.info("curValue=" + curValue);
            for (PowerNetDropdownEntity netDropdown : dropdownList) {
                PowerDemandQueryRespDTO dto = ConvertUtils.sourceToTarget(netDropdown, PowerDemandQueryRespDTO.class);
                if (!CollectionUtils.isEmpty(pointsHisValues.get(netDropdown.getExt1()))) {
                    Map<String, BigDecimal> pointValueMap = new HashMap<>();
                    pointsHisValues.get(netDropdown.getExt1()).forEach(item -> {
                        pointValueMap.put(item.get("time").toString(), DecimalUtil.toBigDecimal(item.get("value")));

                    });
                    dto.setCurDemand(pointValueMap.get(DateUtils.format(curValue.getT(), DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND)));
                    dto.setDataTime(curValue.getT());
                }
                result.add(dto);
            }
            Map<String, Object> valueMap = hisList.get(hisList.size() - 1);
            respDTO.setDataTime(DateUtils.parse(valueMap.get("time").toString(), DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND));
            respDTO.setCurDemand(DecimalUtil.toBigDecimal(valueMap.get("value")));
        }
        return success(result);
    }
@@ -800,12 +917,13 @@
        start = calendar.getTime();
        apiPointValueQueryDTO.setStart(start);
        apiPointValueQueryDTO.setEnd(new Date());
        List<ApiPointValueDTO> monthChartData = dataPointApi.queryPointHistoryValue(apiPointValueQueryDTO);
        List<Double> monthValues = new ArrayList<>();
        if (CollectionUtils.isEmpty(monthChartData)) {
            monthValues = monthChartData.stream().map(item -> item.getV()).collect(Collectors.toList());
            result.setMax(monthValues.stream().max(Double::compareTo).get());
            result.setMin(monthValues.stream().min(Double::compareTo).get());
        Map<String, Object> maxV = dataPointApi.queryPointMaxValueRange(apiPointValueQueryDTO);
        Map<String, Object> minV = dataPointApi.queryPointMaxValueRange(apiPointValueQueryDTO);
        if (maxV != null && maxV.containsKey(pointNo)) {
            result.setMax(new BigDecimal(maxV.get(pointNo).toString()));
        }
        if (minV != null && minV.containsKey(pointNo)) {
            result.setMin(new BigDecimal(minV.get(pointNo).toString()));
        }
        return success(result);
    }
@@ -827,16 +945,10 @@
        calendar0.set(Calendar.MILLISECOND, 0);
        calendar0.set(Calendar.SECOND, 0);
        Date end0 = dto.getEndTime() == null ? calendar0.getTime() : dto.getEndTime();
        calendar0.add(Calendar.MINUTE, -1440);
        calendar0.set(Calendar.MINUTE, 0);
        calendar0.set(Calendar.HOUR_OF_DAY, 0);
        Date start0 = dto.getStartTime() == null ? calendar0.getTime() : dto.getStartTime();

        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH, 1);
        calendar1.set(Calendar.HOUR_OF_DAY, 0);
        calendar1.set(Calendar.MINUTE, 0);
        calendar1.set(Calendar.SECOND, 0);
        calendar1.set(Calendar.MILLISECOND, 0);
        Date start1 = calendar1.getTime();

        List<String> categories = DateUtils.getTimeScale(start0, end0, 60);
        for (String nodeCode : nodeCodeList) {
@@ -877,25 +989,49 @@
            apiPointValueQueryDTO.setStart(start0);
            List<ApiPointValueDTO> chartData = dataPointApi.queryPointHistoryValue(apiPointValueQueryDTO);
            List<Object[]> dataList = new ArrayList<>();
            List<Double> valueList = new ArrayList<>();
            for (ApiPointValueDTO pv : chartData) {
                Object[] data = new Object[2];
                data[0] = DateUtils.format(pv.getT(), DateUtils.FORMAT_YEAR_MONTH_DAY_HOUR_MINUTE_SECOND);
                data[1] = pv.getV();
                dataList.add(data);
                valueList.add(pv.getV());
            }
            powerHistoryDTO.setDataList(dataList);

            //查询月最大最小值
            ApiPointValueQueryDTO apiPointValueQueryDTO1 = new ApiPointValueQueryDTO();
            /*ApiPointValueQueryDTO apiPointValueQueryDTO1 = new ApiPointValueQueryDTO();
            apiPointValueQueryDTO1.setStart(start1);
            apiPointValueQueryDTO1.setEnd(new Date());
            apiPointValueQueryDTO1.setPointNo(pointNo);
            List<ApiPointValueDTO> monthChartData = dataPointApi.queryPointHistoryValue(apiPointValueQueryDTO1);
            if (!CollectionUtils.isEmpty(monthChartData)) {
                List<Double> monthValues = monthChartData.stream().map(item -> item.getV()).collect(Collectors.toList());
                powerHistoryDTO.setMax(monthValues.stream().max(Double::compareTo).get());
                powerHistoryDTO.setMin(monthValues.stream().min(Double::compareTo).get());
            Map<String, Object> maxV = dataPointApi.queryPointMaxValueRange(apiPointValueQueryDTO1);
            Map<String, Object> minV = dataPointApi.queryPointMaxValueRange(apiPointValueQueryDTO1);
            if (maxV != null && maxV.containsKey(pointNo)) {
                powerHistoryDTO.setMax(new BigDecimal(maxV.get(pointNo).toString()));
            }
            if (minV != null && minV.containsKey(pointNo)) {
                powerHistoryDTO.setMin(new BigDecimal(minV.get(pointNo).toString()));
            }*/

            double fsl = 0;
            double max = 0;
            double min = 0;
            double avg = 0;
            if (!CollectionUtils.isEmpty(valueList)) {
                max = valueList.stream().mapToDouble(Double::doubleValue).max().getAsDouble();
                min = valueList.stream().mapToDouble(Double::doubleValue).min().getAsDouble();
                avg = valueList.stream().mapToDouble(Double::doubleValue).average().getAsDouble();

                for (Double val : valueList) {
                    if (val < 0) {
                        fsl += val;
                    }
                }
            }
            powerHistoryDTO.setFsl(new BigDecimal(fsl).setScale(2, BigDecimal.ROUND_HALF_UP));
            powerHistoryDTO.setMax(new BigDecimal(max).setScale(2, BigDecimal.ROUND_HALF_UP));
            powerHistoryDTO.setMin(new BigDecimal(min).setScale(2, BigDecimal.ROUND_HALF_UP));
            powerHistoryDTO.setAvg(new BigDecimal(avg).setScale(2, BigDecimal.ROUND_HALF_UP));

            result.put(nodeCode, powerHistoryDTO);
        }
@@ -1001,9 +1137,9 @@

    @PostMapping("/demand/history-list")
    @Operation(summary = "负荷移植-实测需量有功功率历史(多code)")
    public CommonResult<LinkedHashMap<String, List<Object[]>>> getPowerDemandHistoryList(@RequestBody PowerDemandHisReqDTO dto) {
    public CommonResult<LinkedHashMap<String, PowerHistoryDTO>> getPowerDemandHistoryList(@RequestBody PowerDemandHisReqDTO dto) {
        log.info("请求参数: {}", JSONObject.toJSONString(dto));
        LinkedHashMap<String, List<Object[]>> result = new LinkedHashMap<>();
        LinkedHashMap<String, PowerHistoryDTO> result = new LinkedHashMap<>();

        // 参数校验
        if (CollectionUtils.isEmpty(dto.getCodeList())) {
@@ -1022,7 +1158,16 @@
            startTime = cal.getTime();
        }

        Calendar calendar1 = Calendar.getInstance();
        calendar1.set(Calendar.DAY_OF_MONTH, 1);
        calendar1.set(Calendar.HOUR_OF_DAY, 0);
        calendar1.set(Calendar.MINUTE, 0);
        calendar1.set(Calendar.SECOND, 0);
        calendar1.set(Calendar.MILLISECOND, 0);
        Date start1 = calendar1.getTime();

        for (String code : dto.getCodeList()) {
            PowerHistoryDTO powerHistoryDTO = new PowerHistoryDTO();
            PowerNetFactorQuery powerNetFactorQuery = new PowerNetFactorQuery();
            PowerDemandEntity powerDemandEntity = powerDemandService.getByCode(code);
            PowerNetDropdownEntity powerNetDropdownEntity = powerNetDropdownService.getByNodeCode(code);
@@ -1064,7 +1209,23 @@
                    })
                    .collect(Collectors.toList());

            result.put(code, dataList);
            powerHistoryDTO.setDataList(dataList);

            //查询月最大最小值
            ApiPointValueQueryDTO apiPointValueQueryDTO1 = new ApiPointValueQueryDTO();
            apiPointValueQueryDTO1.setStart(start1);
            apiPointValueQueryDTO1.setEnd(new Date());
            apiPointValueQueryDTO1.setPointNo(pointNo);
            Map<String, Object> maxV = dataPointApi.queryPointMaxValueRange(apiPointValueQueryDTO1);
            Map<String, Object> minV = dataPointApi.queryPointMinValueRange(apiPointValueQueryDTO1);
            if (maxV != null && maxV.containsKey(pointNo)) {
                powerHistoryDTO.setMax(new BigDecimal(maxV.get(pointNo).toString()));
            }
            if (minV != null && minV.containsKey(pointNo)) {
                powerHistoryDTO.setMin(new BigDecimal(minV.get(pointNo).toString()));
            }

            result.put(code, powerHistoryDTO);
        }

        return success(result);
@@ -1104,22 +1265,19 @@
        return success(result);
    }

    @GetMapping("/power-maxdemand/page")
    @PostMapping("/power-maxdemand/page")
    @Operation(summary = "负荷移植-最大需量发生记录分页")
    public CommonResult<PageResult<PowerMaxDemandMainDTO>> getPowerMaxDemandMainPage(@Validated PowerMaxDemandMainPageReqVO reqVO) {
    public CommonResult<PageResult<PowerMaxDemandMainDTO>> getPowerMaxDemandMainPage(@RequestBody PowerMaxDemandMainPageReqVO reqVO) {
        if (StringUtils.isBlank(reqVO.getCode())) {
            log.info("code is blank");
            return error(GlobalErrorCodeConstants.BAD_REQUEST);
        }
        PageResult<PowerMaxdemandMainEntity> page = powerMaxDemandMainService.page(reqVO);
        PageResult<PowerMaxDemandMainDTO> result = BeanUtils.toBean(page, PowerMaxDemandMainDTO.class);
        /*List<String> parentIds = result.getList()
                .stream()
                .map(PowerMaxDemandMainDTO::getId)
                .collect(Collectors.toList());
        List<PowerMaxdemandDetEntity> children = powerMaxdemandDetService.selectListByRelIds(parentIds);
        Map<String, List<PowerMaxdemandDetEntity>> childrenMap = children.stream()
                .collect(Collectors.groupingBy(PowerMaxdemandDetEntity::getRelId));*/
        result.getList().forEach(dto0 -> {
            List<PowerMaxdemandDetEntity> detList0 = powerMaxdemandDetService.selectListByRelId(dto0.getId(), dto0.getOccurTime());
            dto0.setChildren(ConvertUtils.sourceToTarget(detList0, PowerMaxdemandDetDTO.class));
            if (CollectionUtils.isEmpty(dto0.getChildren())) {
            if (!CollectionUtils.isEmpty(dto0.getChildren())) {
                dto0.getChildren().forEach(dto1 -> {
                    List<PowerMaxdemandDetEntity> detList1 = powerMaxdemandDetService.selectListByRelId(dto1.getId(), dto1.getOccurTime());
                    dto1.setChildren(ConvertUtils.sourceToTarget(detList1, PowerMaxdemandDetDTO.class));
@@ -1128,4 +1286,159 @@
        });
        return success(result);
    }

    @PostMapping("/power-maxdemand/det-list")
    @Operation(summary = "负荷移植-最大需量发生记录详情")
    public CommonResult<List<PowerMaxdemandDetDTO>> getPowerMaxDemandDetList(@RequestBody Map<String, Object> params) {
        String relId = (String) params.get("relId");
        if (StringUtils.isBlank(relId)) {
            return error(GlobalErrorCodeConstants.BAD_REQUEST);
        }
        List<PowerMaxdemandDetEntity> list = powerMaxdemandDetService.selectListByRelId(relId);
        return success(ConvertUtils.sourceToTarget(list, PowerMaxdemandDetDTO.class));
    }

    @GetMapping("/power-price/list")
    @Operation(summary = "获取峰谷平电价信息")
    public CommonResult<List<PowerPriceMainDTO>> getPowerPriceList(@RequestParam Map<String, Object> params) {
        List<PowerPriceMainDTO> result = powerPriceMainService.list(params);
        return success(result);
    }

    @PostMapping("/power-price/save")
    @Operation(summary = "保存峰谷平电价信息")
    public CommonResult<Boolean> savePowerPriceList(@RequestBody PowerPriceMainDTO mainDTO) {
        return success(powerPriceMainService.save(mainDTO));
    }

    @PostMapping("/power-price/update")
    @Operation(summary = "修改峰谷平电价信息")
    public CommonResult<Boolean> updatePowerPriceList(@RequestBody PowerPriceMainDTO mainDTO) {
        if (StringUtils.isBlank(mainDTO.getId())) {
            return error(GlobalErrorCodeConstants.BAD_REQUEST);
        }
        return success(powerPriceMainService.update(mainDTO));
    }

    @PostMapping("/factor-control/list")
    @Operation(summary = "功率因数调整结果查询")
    public CommonResult<List<PowerFactorControlDTO>> powerFactorControlList(@RequestBody PowerFactorReqVO powerFactorReqVO) {
        List<PowerFactorControlDTO> result = new ArrayList<>();
        Map<String, Object> chartMap = new HashMap<>();
        List<ChartParamDTO> chartList = mcsApi.getChartParamList(CommonConstant.POWER_CODE);
        chartList.forEach(item -> {
            chartMap.put(item.getParamName(), item.getParamCode());
        });
        List<String> contentList = powerFactorReqVO.getContentList();
        if (CollectionUtils.isEmpty(contentList)) {
            log.info("contentList为空");
            return new CommonResult<>();
        }
        List<Integer> contentListNew = new ArrayList<>();
        contentList.forEach(item -> {
            chartMap.forEach((key, value) -> {
                if (item.contains(key)) {
                    contentListNew.add(Integer.parseInt(value.toString()));
                }
            });
        });

        Calendar calendar = Calendar.getInstance();
        calendar.set(Calendar.MILLISECOND, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MINUTE, 0);

        if (!CollectionUtils.isEmpty(powerFactorReqVO.getContentList())) {

        }
        MdkScheduleReqDTO dto = new MdkScheduleReqDTO();
        dto.setScheduleTime(calendar.getTime());
        dto.setScheduleCode("AnsteelOffPowerAC");
        Map<String, String> dynamicSettings = new HashMap<>();
        dynamicSettings.put("option_param", JSONArray.toJSONString(contentListNew.stream().toArray(Integer[]::new)));
        List<String> cosParam = new ArrayList<>();
        cosParam.add(powerFactorReqVO.getAdjustValueCcpp().toString());
        cosParam.add(powerFactorReqVO.getAdjustValue135().toString());
        cosParam.add(powerFactorReqVO.getAdjustValueTrt().toString());
        dynamicSettings.put("cos_param", JSONArray.toJSONString(cosParam));
        dto.setDynamicSettings(dynamicSettings);

        log.info("调度方案开始执行，" + JSONObject.toJSONString(dto));
        // MdkScheduleRespDTO mdkScheduleRespDTO = mdkApi.doSchedule(dto);
        //log.info("调度方案执行完成，" + mdkScheduleRespDTO);

        /*String statusCode = mdkScheduleRespDTO.getStatusCode();
        if (!CommonConstant.MDK_STATUS_100.equals(statusCode)) {
            log.info("statusCode=" + statusCode);
            return CommonResult.error(GlobalErrorCodeConstants.UNKNOWN.getCode(), "工序异常，无计算结果");
        }

        Map<String, Object> data = mdkScheduleRespDTO.getResult();*/
        // 调整后的功率因数
        // List<String> adjustCosList = Arrays.asList(data.get("adjust_cos").toString().split(","));
        String fakeData = "[0.39,0.98,0.98,0 91,1.0,0.93,0.86,0.89,0.98,0.9,0.97,0.89,0.84,0.91]";
        List<BigDecimal> adjustCosList = JSONArray.parseArray(fakeData, BigDecimal.class);

        // 无功管控结果
        BigDecimal back_wugong_buchang = new BigDecimal(36.92);
        adjustCosList.add(back_wugong_buchang);

        Map<Integer, BigDecimal> adjustCosMap = new HashMap<>();
        for (int i = 0; i < adjustCosList.size(); i++) {
            adjustCosMap.put(i, adjustCosList.get(i));
        }

        List<PowerFactorControlEntity> list = powerFactorControlService.list();
        if (CollectionUtils.isEmpty(list)) {
            log.info("list is empty");
            return success(result);
        }

        for (int i = 0; i < list.size(); i++) {
            PowerFactorControlEntity entity = list.get(i);
            PowerFactorControlDTO controlDTO = new PowerFactorControlDTO();
            controlDTO.setName(entity.getName());
            controlDTO.setSort(entity.getSort());
            try {
                // 预测结果
                switch (ProcessConfDataTypeEnum.getEumByCode(entity.getDataType())) {
                    case DATAPOINT:
                        List<String> params1 = new ArrayList<>();
                        params1.add(entity.getPredResult());
                        Map<String, Object> pointValues = dataPointApi.queryPointsRealValue(params1);
                        if (!CollectionUtils.isEmpty(pointValues)) {
                            controlDTO.setPredResult(DecimalUtil.toBigDecimal(pointValues.get(entity.getPredResult())));
                        }
                        break;
                    case PREDICTVALUE:
                        PredictLastValueReqVO reqVO = new PredictLastValueReqVO();
                        calendar.set(calendar.HOUR_OF_DAY, 0);
                        reqVO.setPredictTime(calendar.getTime());
                        List<String[]> itemNos = new ArrayList<>();
                        if (StringUtils.isNotBlank(entity.getPredResult())) {
                            itemNos.add(entity.getPredResult().split(","));
                        }
                        reqVO.setItemNos(itemNos);
                        Map<String, BigDecimal> preValues = mcsApi.getPredictValueByTime(reqVO);
                        if (preValues.get(entity.getPredResult()) != null) {
                            controlDTO.setPredResult(new BigDecimal(preValues.get(entity.getPredResult()).toString()));
                        }
                        break;
                    default:
                        break;
                }

                // 管控结果
                if (adjustCosMap.containsKey(entity.getCosIndex())) {
                    controlDTO.setAdjustCos(adjustCosMap.get(entity.getCosIndex()));
                }
            } catch (Exception ex) {
                log.info(controlDTO.getName() + "获取预测值异常," + ex.getMessage());
                ex.printStackTrace();
            }
            result.add(controlDTO);
        }
        log.info("result===" + JSONObject.toJSONString(result));
        return success(result);
    }
}