tofly-dyrq/src/main/java/com/tofly/dyrq/custom/service/impl/CustomPointServiceImpl.java

package com.tofly.dyrq.custom.service.impl;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.sun.tools.sjavac.Log;
import com.tofly.common.core.util.Date8Util;
import com.tofly.dyrq.custom.entity.UpdatePoint;
import com.tofly.dyrq.custom.mapper.CustomPlanMapper;
import com.tofly.dyrq.custom.mapper.CustomPointMapper;
import com.tofly.dyrq.custom.service.CustomPointService;
import com.tofly.dyrq.entity.PlanChild;
import com.tofly.dyrq.entity.PlanPointTemp;
import com.tofly.dyrq.entity.SysDeviceType;
import com.tofly.dyrq.entity.TfPlanPathTemp;
import com.tofly.dyrq.service.PlanChildService;
import com.tofly.dyrq.service.PlanPointTempService;
import com.tofly.dyrq.service.SysDeviceTypeService;
import com.tofly.dyrq.service.TfPlanPathTempService;

import lombok.AllArgsConstructor;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.stream.Collectors;

@Service
@AllArgsConstructor
public class CustomPointServiceImpl implements CustomPointService {
    private CustomPointMapper customPointMapper;
    private PlanPointTempService planPointTempService;
    private PlanChildService planChildService;
    private TfPlanPathTempService planPathTempService;
    private final CustomPlanMapper customPlanMapper;
    private final SysDeviceTypeService sysDeviceTypeService;

    @Override
    @Transactional
    public Map<String, Long> updatePointOrPathIsover(List<UpdatePoint> updatePoints) {
        Map<String, Long> transfer = new HashMap<>();
        List<Long> childList = new ArrayList<>();
        HashSet<Long> childIds = new HashSet();
        
        for (UpdatePoint u : updatePoints) {
            if (u.getTempId() != null && u.getCheckTime() != null && u.getGpsSpeed() != null) {
                if ("0".equals(u.getType())) {
                    String pointChildPlanState = customPointMapper.getStateByPointId(u.getTempId());
                    if ("7".equals(pointChildPlanState)) {
                        transfer.put("pointTempId", u.getTempId());
                        continue;
                    }
                    planPointTempService.update(Wrappers.<PlanPointTemp>lambdaUpdate()
                            .set(PlanPointTemp::getIsover, "1")
                            .set(PlanPointTemp::getOverDate, u.getCheckTime())
                            .set(PlanPointTemp::getGpsSpeed, u.getGpsSpeed())
                            .eq(PlanPointTemp::getId, u.getTempId()));
                } else if ("1".equals(u.getType())) {
                    String childPlanState = customPointMapper.getStateByPath(u.getTempId());
                    if ("7".equals(childPlanState)) {
                        transfer.put("pathTempId", u.getTempId());
                        continue;
                    } else {
                        if (!childList.contains(u.getPlanChildId())) {
                            childList.add(u.getPlanChildId());
                        }
                    }
                    planPathTempService.update(Wrappers.<TfPlanPathTemp>lambdaUpdate()
                            .set(TfPlanPathTemp::getIsover, "1")
                            .set(TfPlanPathTemp::getOverDate, u.getCheckTime())
                            .set(TfPlanPathTemp::getGpsSpeed, u.getGpsSpeed())
                            .eq(TfPlanPathTemp::getId, u.getTempId()));
                    //更新完成点所属线的完成率
                    Long pointTempId =planPathTempService.getById(u.getTempId()).getTempId();
                    int isOverNum = planPathTempService.count(Wrappers.<TfPlanPathTemp>lambdaQuery().eq(TfPlanPathTemp::getTempId, pointTempId).eq(TfPlanPathTemp::getIsover, "1"));
                    int allNum = planPathTempService.count(Wrappers.<TfPlanPathTemp>lambdaQuery().eq(TfPlanPathTemp::getTempId, pointTempId));
                    double pathOver = new BigDecimal((float) isOverNum / allNum).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
                    PlanPointTemp one = new PlanPointTemp();
                    one.setId(pointTempId);
                    one.setPathIsover(new BigDecimal(pathOver));
                    planPointTempService.updateById(one);
                }
            }
            childIds.add(u.getPlanChildId());
        }
        Log.warn("#############################1");
        //批量更新所有计划点，线完成率
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                String ids = StringUtils.join(childIds, ",");
                percentUpdate(ids);
            }
        });
//        for (Long cid : childList) {
//            Double percent = (double) planPathTempService.list(Wrappers.<TfPlanPathTemp>lambdaQuery().eq(TfPlanPathTemp::getChildPlanId, cid).eq(TfPlanPathTemp::getIsover, 1)).size()
//                    / (double) planPathTempService.list(Wrappers.<TfPlanPathTemp>lambdaQuery().eq(TfPlanPathTemp::getChildPlanId, cid)).size();
//            planChildService.update(Wrappers.<PlanChild>lambdaUpdate()
//                    .set(PlanChild::getPercent, percent)
//                    .set(PlanChild::getPercent1, percent)
//                    .eq(PlanChild::getId, cid));
//            planChildService.update(Wrappers.<PlanChild>lambdaUpdate()
//                    .set(PlanChild::getChildPlanState, "3")
//                    .eq(PlanChild::getPercent1, 1.00)
//                    .eq(PlanChild::getId, cid));
//        }
        Log.warn("#############################3");
        return transfer;
    }

    @Override
    public void percentUpdate(String childPlanIds) {
        List<String> list = Arrays.asList(childPlanIds.split(","));
        Log.warn("#############################2");
        for (String sid : list) {
            Long childPlanId = Long.parseLong(sid);
            Date now = Date8Util.getCurrentDate();
            //查询当天的计划
            Map param1 = new HashMap();
            param1.put("now", now);
            int pointTotal = 0;
            int pointIsoverTotal = 0;
            int isOver = 0;  //---------巡检点，巡检线isover个数，其他设备check个数
            int total = 0; //point_temp个数
            double percent = 0;
            double percent1 = 0;
            Map plan = customPlanMapper.getTodayPlan(childPlanId).get(0);

            //查询包含巡检检查内容的类型
            List<SysDeviceType> devices = sysDeviceTypeService.list(Wrappers.<SysDeviceType>lambdaQuery().isNotNull(SysDeviceType::getCheckContent));
            Set<Long> checkTypes = new HashSet<>();
            devices.stream().filter(n -> !checkTypes.add(n.getPointTypeId()))
                    .collect(Collectors.toSet());

            //更新巡检线录入状态
            if ("1".equals(plan.get("type"))) {
                List<Map> pathTotal = customPlanMapper.getPathTotalInfo(childPlanId);
                total = Integer.valueOf(pathTotal.get(0).get("total").toString());
                isOver = checkTypes.contains(plan.get("deviceTypeId")) ? Integer.valueOf(pathTotal.get(0).get("checkTotal").toString()) : Integer.valueOf(pathTotal.get(0).get("isovertotal").toString());
                pointTotal = Integer.valueOf(pathTotal.get(0).get("pointTotal").toString());
                pointIsoverTotal = Integer.valueOf(pathTotal.get(0).get("pointIsoverTotal").toString());
//                percent1 = pointTotal == 0 ? 0 : new BigDecimal((float) pointIsoverTotal / pointTotal).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
//                percent = pointTotal == 0 ? 0 : new BigDecimal((float) isOver / total).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
                //修改percent1 为point_temp到位情况
                percent = pointTotal == 0 ? 0 : new BigDecimal((float) isOver / total).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
                percent1 = pointTotal == 0 ? 0 : new BigDecimal ((float) pointIsoverTotal / pointTotal).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();

                //更新到位条数
                PlanChild planChild = new PlanChild();
                planChild.setId(childPlanId);
                planChild.setPercent(percent);
                planChild.setPercent1(percent1);
                planChild.setTotal1(new BigDecimal(pointTotal));
                planChild.setIsovertototal(percent * total);
                planChild.setIsovertototal1(new BigDecimal(pointIsoverTotal));
                planChild.setIsovertototal0(new BigDecimal(isOver));
                planChildService.updateById(planChild);

                //更新线到位比例
//                List<PlanPointTemp> stateList = planPointTempService.list(Wrappers.<PlanPointTemp>lambdaQuery().eq(PlanPointTemp::getChildPlanId, childPlanId)
//                        .eq(PlanPointTemp::getState, "0"));
                List<PlanPointTemp> pointTemps = new ArrayList<>();
                //点所属的线信息更新也转移到到位接口
//                for (PlanPointTemp pointTemp : stateList) {
//                    Long pointTempId = pointTemp.getId();
//                    int isOverNum = planPathTempService.count(Wrappers.<TfPlanPathTemp>lambdaQuery().eq(TfPlanPathTemp::getTempId, pointTempId).eq(TfPlanPathTemp::getIsover, "1"));
//                    int allNum = planPathTempService.count(Wrappers.<TfPlanPathTemp>lambdaQuery().eq(TfPlanPathTemp::getTempId, pointTempId));
//                    double pathOver = new BigDecimal((float) isOverNum / allNum).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
//                    PlanPointTemp one = new PlanPointTemp();
//                    one.setId(pointTempId);
//                    one.setPathIsover(new BigDecimal(pathOver));
//                    planPointTempService.updateById(one);
//                }

                //更新录入状态
                List<Map> pathMax = customPlanMapper.getPathMaxSpeed(childPlanId);
                for (Map i : pathMax) {
                    PlanPointTemp planPointTemp = new PlanPointTemp();
                    planPointTemp.setIsover("1");
                    planPointTemp.setGpsSpeed((BigDecimal) i.get("gpsSpeed"));
                    planPointTemp.setState("1");
                    planPointTemp.setId(Long.parseLong(i.get("tempId").toString()));
                    planPointTemp.setOverDate((Date) i.get("overDate"));
                    pointTemps.add(planPointTemp);
//                    planPointTempService.updateById(planPointTemp);
                }
                planPointTempService.updateBatchById(pointTemps);
            } else {
                //更新巡检点录入状态
                total = planPointTempService.count(Wrappers.<PlanPointTemp>lambdaQuery().eq(PlanPointTemp::getChildPlanId, childPlanId));
                int pointIsOver = planPointTempService.count(Wrappers.<PlanPointTemp>lambdaQuery().eq(PlanPointTemp::getChildPlanId, childPlanId).eq(PlanPointTemp::getIsover, "1"));
                int pointIsCheck = planPointTempService.count(Wrappers.<PlanPointTemp>lambdaQuery().eq(PlanPointTemp::getChildPlanId, childPlanId).eq(PlanPointTemp::getCheckState, "1"));
                isOver = checkTypes.contains(Long.parseLong(plan.get("deviceTypeId").toString())) ? pointIsCheck : pointIsOver;
                percent = isOver == 0 ? 0 : new BigDecimal((float) isOver / total).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
                //更新到位点数
                PlanChild planChild = new PlanChild();
                planChild.setId(childPlanId);
                planChild.setPercent(percent);
                planChild.setPercent1(percent);
                planChild.setTotal(Double.valueOf(total));
                planChild.setTotal1(new BigDecimal(total));
                planChild.setIsovertototal(Double.valueOf(isOver));
                planChild.setIsovertototal1(new BigDecimal(isOver));
                planChildService.updateById(planChild);
            }
            //更新计划状态 完成进度percent1为1 计划变成完成状态
            planChildService.update(Wrappers.<PlanChild>lambdaUpdate().set(PlanChild::getChildPlanState, "3")
                    .eq(PlanChild::getPercent1, 1).eq(PlanChild::getId, childPlanId));
        }
        Log.warn("#############################4");
    }


    /**
     * 更新到位点信息
     * @param childPlanId
     * @param temptIds
     */
    public void pointPlanUpdate(Long childPlanId,List<Long> temptIds) {
        int pointTotal = 0;
        int pointIsoverTotal = 0;
        int isOver = 0;  //---------巡检点，巡检线isover个数，其他设备check个数
        int total = 0; //point_temp个数
        double percent = 0;
        double percent1 = 0;
        Map plan = customPlanMapper.getTodayPlan(childPlanId).get(0);
        PlanChild planChild= planChildService.getById(childPlanId);

        //查询包含巡检检查内容的类型
        List<SysDeviceType> devices = sysDeviceTypeService.list(Wrappers.<SysDeviceType>lambdaQuery().isNotNull(SysDeviceType::getCheckContent));
        Set<Long> checkTypes = new HashSet<>();
        devices.stream().filter(n -> !checkTypes.add(n.getPointTypeId()))
                .collect(Collectors.toSet());

        //更新巡检线录入状态
        if ("1".equals(plan.get("type"))) {
            List<Map> pathTotal = customPlanMapper.getPathTotalInfo(childPlanId);
            total = Integer.valueOf(pathTotal.get(0).get("total").toString());
            isOver = checkTypes.contains(plan.get("deviceTypeId")) ? Integer.valueOf(pathTotal.get(0).get("checkTotal").toString()) : Integer.valueOf(pathTotal.get(0).get("isovertotal").toString());
            pointTotal = Integer.valueOf(pathTotal.get(0).get("pointTotal").toString());
            pointIsoverTotal = Integer.valueOf(pathTotal.get(0).get("pointIsoverTotal").toString());
//                percent1 = pointTotal == 0 ? 0 : new BigDecimal((float) pointIsoverTotal / pointTotal).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
//                percent = pointTotal == 0 ? 0 : new BigDecimal((float) isOver / total).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
            //修改percent1 为point_temp到位情况
            percent = pointTotal == 0 ? 0 : new BigDecimal((float) isOver / total).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
            percent1 = pointTotal == 0 ? 0 : new BigDecimal ((float) pointIsoverTotal / pointTotal).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();

            //更新到位条数
            PlanChild planChildUpdate = new PlanChild();
            planChildUpdate.setId(childPlanId);
            planChildUpdate.setPercent(percent);
            planChildUpdate.setPercent1(percent1);
            planChildUpdate.setTotal1(new BigDecimal(pointTotal));
            planChildUpdate.setIsovertototal(percent * total);
            planChildUpdate.setIsovertototal1(new BigDecimal(pointIsoverTotal));
            planChildUpdate.setIsovertototal0(new BigDecimal(isOver));
            planChildService.updateById(planChildUpdate);

            //更新线到位比例
            List<PlanPointTemp> stateList = planPointTempService.list(Wrappers.<PlanPointTemp>lambdaQuery().eq(PlanPointTemp::getChildPlanId, childPlanId)
                    .eq(PlanPointTemp::getState, "0"));
            List<PlanPointTemp> pointTemps = new ArrayList<>();
            List<TfPlanPathTemp> pathTemps = new ArrayList<>();
            for (PlanPointTemp pointTemp : stateList) {
                Long pointTempId = pointTemp.getId();
                int isOverNum = planPathTempService.count(Wrappers.<TfPlanPathTemp>lambdaQuery().eq(TfPlanPathTemp::getTempId, pointTempId).eq(TfPlanPathTemp::getIsover, "1"));
                int allNum = planPathTempService.count(Wrappers.<TfPlanPathTemp>lambdaQuery().eq(TfPlanPathTemp::getTempId, pointTempId));
                double pathOver = new BigDecimal((float) isOverNum / allNum).setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();
                PlanPointTemp one = new PlanPointTemp();
                one.setId(pointTempId);
                one.setPathIsover(new BigDecimal(pathOver));
                planPointTempService.updateById(one);
            }
        }
    }


}