guzijian / bsth-alcohol-sign · Files

package com.ruoyi.service.impl;

import com.alibaba.fastjson2.JSON;
import com.ruoyi.common.SignStatusEnum;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.domain.DriverScheduling;
import com.ruoyi.domain.DriverSchedulingV1;
import com.ruoyi.driver.domain.Driver;
import com.ruoyi.driver.service.IDriverService;
import com.ruoyi.in.domain.SignIn;
import com.ruoyi.in.domain.SignInV1;
import com.ruoyi.in.service.SignInServiceV1;
import com.ruoyi.pojo.vo.bigViewVo.FleetInfoVo;
import com.ruoyi.pojo.vo.bigViewVo.FleetState;
import com.ruoyi.pojo.vo.bigViewVo.LineInfo;
import com.ruoyi.scheduling.service.SchedulingServiceV1;
import com.ruoyi.service.BigViewServiceV1;
import com.ruoyi.template.domain.FleetLineTemplate;
import com.ruoyi.template.service.IFleetLineTemplateService;
import com.ruoyi.utils.ConstDateUtil;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.EnableAsync;
import org.springframework.stereotype.Service;

import java.text.MessageFormat;
import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;

import static com.ruoyi.common.ConstSignInConstSignInProperties.SIGN_IN_ERROR_COUNT;
import static com.ruoyi.common.ErrorTypeProperties.SIGN_IN_ERROR;
import static com.ruoyi.common.redispre.GlobalRedisPreName.REDIS_SIGN_IN_DRIVER_ALCOHOL_OVERFLOW;

/**
 * @author liujun
 * @date 2024年09月25日 14:38
 */
@Slf4j
@Service
@EnableAsync
public class BigViewServiceV1Impl implements BigViewServiceV1 {
    @Autowired
    private IFleetLineTemplateService fleetLineTemplateService;
    @Autowired
    private SchedulingServiceV1 schedulingServiceV1;
    @Autowired
    private IDriverService driverService;
    @Autowired
    private SignInServiceV1 signInServiceV1;

    @Autowired
    private RedisCache redisCache;


    private static final String LINE_SIGN_NBBM_KEY = "sign:report:nbbm:{0}:{1}";
    private static final String LINE_SIGN_NBBM_LOCK_KEY = "sign:report:lock:nbbm:{0}:{1}";

    private static final String LINE_SIGN_STATUS_KEY = "sign:report:status:{0}:{1}";
    private static final String LINE_SIGN_STATUS_LOCK_KEY = "sign:report:lock:status:{0}:{1}";

    private static final String LINE_SIGN_REPORT_FLEET_KEY = "sign:report:fleet:{0}";

    private static final String BIG_VIEW_LINE_KEY = "big:view:line:{0}";


    @Override
    public void asyncRefreshRedisValue(SignIn signIn, Driver driver, DriverScheduling driverScheduling, String dateStr, Date date) throws InterruptedException {
        refreshRedisDriver(signIn, driver, dateStr, driverScheduling, date);
        refreshRedisLine(signIn, driverScheduling, dateStr);
    }

    @Override
    public AjaxResult queryBigViewQueryLineInfo(Date date) {
        String dateStr = DateUtils.FAST_YYYY_MM_DD.format(date);
        String key = MessageFormat.format(BIG_VIEW_LINE_KEY, dateStr);

        List<FleetInfoVo> fleetInfoVos = getFleetInfoVoBtRedis(key);
        if (CollectionUtils.isEmpty(fleetInfoVos)) {
            fleetInfoVos = combationFleetInfoVoBtRedis(key, dateStr);
        }

        return AjaxResult.success(fleetInfoVos);
    }


    @Override
    public LineInfo refreshRedisDriver(SignIn signIn, Driver driver, String dateStr, DriverScheduling driverScheduling, Date date) {
        LineInfo.PersonInfoVo personInfoVo = combationPersonInfoVo(driver, signIn);

        LineInfo lineInfo = null;
        String key = MessageFormat.format(LINE_SIGN_NBBM_KEY, dateStr, driverScheduling.getNbbm());

        for (int i = 0; i < 1000; i++) {
            String lockKey = MessageFormat.format(LINE_SIGN_NBBM_LOCK_KEY, dateStr, driverScheduling.getNbbm());
            if (redisCache.setNx(lockKey, 1, 10L, TimeUnit.SECONDS)) {

                try {
                    lineInfo = getLineInfoByRedis(key);
                    if (Objects.isNull(lineInfo)) {
                        lineInfo = queryLineInfo(date, signIn, driverScheduling);
                    }

                    if (Objects.isNull(lineInfo)) {
                        return null;
                    }

                    setDriverByPost(driver, lineInfo, personInfoVo);
                    redisCache.setCacheObject(key, JSON.toJSONString(lineInfo), 25, TimeUnit.HOURS);
                    return lineInfo;
                } finally {
                    redisCache.deleteObject(lockKey);
                }

            }

            try {
                log.info("没有获取到redis锁，等待1秒钟后再试");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                log.error("刷新redis中首页的driver数据异常，[{}],[{}],[{}]", signIn, driver, driverScheduling, e);
            }
        }
        log.info("已1000秒获取锁等待没有获取到锁，已放弃操作，[{}],[{}],[{}]", signIn, driver, driverScheduling);
        return lineInfo;
    }


    @Override
    public FleetState refreshRedisLine(SignIn signIn, DriverScheduling driverScheduling, String dateStr) throws InterruptedException {

        FleetState fleetState = new FleetState();
        fleetState.setLineName(driverScheduling.getLineName());
        fleetState.setState(switchSignStatus(signIn));
        fleetState.setFleetName(driverScheduling.getFleetName());

        String key = MessageFormat.format(LINE_SIGN_STATUS_KEY, dateStr, driverScheduling.getLineName());
        FleetState source = redisCache.getCacheObject(key);

        if (Objects.isNull(source) || Objects.isNull(source.getState()) || (fleetState.getState() > source.getState())) {
            boolean flag = true;
            String lockKey = MessageFormat.format(LINE_SIGN_STATUS_LOCK_KEY, dateStr, driverScheduling.getLineName());
            for (int i = 0; i < 10000; i++) {
                if (redisCache.setNx(lockKey, 1, 10L, TimeUnit.SECONDS)) {
                    try {
                        redisCache.setCacheObject(key, JSON.toJSONString(fleetState), 25, TimeUnit.HOURS);
                    } finally {
                        redisCache.deleteObject(lockKey);
                    }

                    flag = false;
                    break;
                }
                log.info("redis的[{}]锁已经被占用，1秒钟后再试", key);
                Thread.sleep(1000);
            }

            if (flag) {
                log.warn("redis的[{}]数据没有刷新成功[{}]", key, fleetState);
            }
        }
        return fleetState;
    }

    @Override
    public AjaxResult getAjaxResultByDriverSignInfo(SignIn signIn) {
        String key = StringUtils.join(REDIS_SIGN_IN_DRIVER_ALCOHOL_OVERFLOW, ConstDateUtil.FAST_YYYY_MM_DD.format(new Date()), ":", signIn.getJobCode());
        // 驾驶员酒精测试连续超标两次则提示换人
        Integer count = redisCache.getCacheObject(key);
        if (Objects.isNull(count) || count.equals(0)) {
            count = 1;
            redisCache.setCacheObject(key, count, 1, TimeUnit.DAYS);
        } else {
            redisCache.setCacheObject(key, ++count, 1, TimeUnit.DAYS);
        }
        if (SIGN_IN_ERROR_COUNT.compareTo(count) <= 0) {
            SignInV1 signInV1 = new SignInV1();
            BeanUtils.copyProperties(signIn, signInV1);
            return AjaxResult.success(SIGN_IN_ERROR + ": " + (StringUtils.isEmpty(signIn.getRemark()) ? "" : signIn.getRemark()) + "酒精测试不通过" + count + "次请更换车辆驾驶员。", signIn);
        }
        return null;
    }

    @Override
    public boolean isNormal(SignIn signIn) {
        return Objects.nonNull(signIn) && Objects.equals(signIn.getExType(), 0);
    }


    @Override
    public boolean isEarly(SignIn signIn) {
        return Objects.nonNull(signIn) && signIn.getExType() >= 20 && signIn.getExType() < 30;
    }


    @Override
    public boolean isSignStatusWineEnum(SignIn signIn) {
        return Objects.nonNull(signIn) && Objects.nonNull(signIn.getExType()) && signIn.getExType() % 10 == 3;
    }


    @Override
    public boolean isSignStatusDelayEnum(SignIn signIn) {
        return Objects.nonNull(signIn) && Objects.nonNull(signIn.getExType()) && signIn.getExType() >= 30 && signIn.getExType() < 40;
    }

    @Override
    public boolean isSignStatusZoneEnum(SignIn signIn) {
        return !isSignStatusWineEnum(signIn);
    }

    @Override
    public boolean isDriver(Driver driver) {
        return Objects.nonNull(driver) && StringUtils.isNotEmpty(driver.getPosts()) && StringUtils.indexOf(driver.getPosts(), "驾驶员") > -1;
    }


    private List<FleetInfoVo> getFleetInfoVoOfRedis(String key) {
        try {
            String jsonStr = redisCache.getCacheObject(key);
            if (StringUtils.isEmpty(jsonStr)) {

                log.info("redis中没有当天的数据[{}]", key);
                return Collections.emptyList();
            }
            return JSON.parseArray(jsonStr, FleetInfoVo.class);
        } catch (Exception e) {
            log.error("从redis中获取数据异常，[{}]", key, e);
        }
        return null;
    }

    private List<FleetInfoVo> combationFleetInfoVo(String redisKey) {

        List<FleetLineTemplate> fleetLineTemplates = fleetLineTemplateService.selectFleetLineTemplateList();
        if (CollectionUtils.isEmpty(fleetLineTemplates)) {
            return null;
        }

        Map<String, List<FleetLineTemplate>> groupFleetLingTemp = fleetLineTemplates.stream().collect(Collectors.groupingBy(FleetLineTemplate::getFleetName, Collectors.toList()));

        List<FleetInfoVo> fleetInfoVos = new ArrayList<>();

        groupFleetLingTemp.forEach((key, vals) -> {
            FleetInfoVo fleetInfoVo = new FleetInfoVo();
            fleetInfoVo.setTitle(key);

            if (CollectionUtils.isNotEmpty(vals)) {
                List<FleetInfoVo.FleetInfo> fleetInfoVoFleetInfos = new ArrayList<>();
                List<FleetState> fleetStates = new ArrayList<>();
                vals.forEach(fl -> {
                    FleetInfoVo.FleetInfo fleetInfo = new FleetInfoVo.FleetInfo();
                    fleetInfo.setLineName(fl.getLineName());
                    fleetInfoVoFleetInfos.add(fleetInfo);

                    FleetState fleetState = new FleetState();
                    fleetState.setLineName(fl.getLineName());
                    fleetState.setState(0);

                    fleetStates.add(fleetState);
                });
                fleetInfoVo.setFleetInfos(fleetInfoVoFleetInfos);
                fleetInfoVo.setFleetStates(fleetStates);
            }
            fleetInfoVos.add(fleetInfoVo);
        });

        redisCache.setCacheObject(redisKey, JSON.toJSONString(fleetInfoVos), 25, TimeUnit.HOURS);
        return fleetInfoVos;
    }

    private LineInfo getLineInfoByRedis(String key) {
        try {
            String jsonStr = redisCache.getCacheObject(key);
            if (StringUtils.isEmpty(jsonStr)) {
                return null;
            }
            return JSON.parseObject(jsonStr, LineInfo.class);
        } catch (Exception e) {
            log.error("从redis中获取LineInfo 异常:[{}]", key, e);
        }
        return null;
    }

    private LineInfo queryLineInfo(Date date, SignIn signIn, DriverScheduling driverScheduling) {
        List<DriverSchedulingV1> driverSchedulingV1List = schedulingServiceV1.queryByNbbmAndDate(driverScheduling.getNbbm(), date);
        if (CollectionUtils.isEmpty(driverSchedulingV1List)) {
            return null;
        }

        LineInfo lineInfo = new LineInfo();
        lineInfo.setLineName(driverScheduling.getLineName());
        lineInfo.setFleetName(driverScheduling.getFleetName());
        lineInfo.setNbbm(driverScheduling.getNbbm());

        List<DriverSchedulingV1> otherDriverSchedulingV1List = driverSchedulingV1List.stream().filter(dc -> !Objects.equals(dc.getJobCode(), signIn.getJobCode())
                && Objects.nonNull(dc.getSignInId())).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(otherDriverSchedulingV1List)) {
            return lineInfo;
        }

        Map<String, List<DriverScheduling>> maps = otherDriverSchedulingV1List.stream().collect(Collectors.groupingBy(DriverSchedulingV1::getJobCode, Collectors.toList()));

        for (Map.Entry<String, List<DriverScheduling>> entry : maps.entrySet()) {
            if (Objects.isNull(entry.getValue())) {
                continue;
            }
            Driver otherDriver = driverService.selectDriverByJobCode(entry.getKey());
            if (Objects.isNull(otherDriver)) {
                continue;
            }
            SignInV1 otherSign = null;
            SignIn otherTagetSign = null;

            for (DriverScheduling sourceDriverScheduling : entry.getValue()) {
                SignInV1 otherSign1 = signInServiceV1.getById(sourceDriverScheduling.getSignInId());
                if (Objects.isNull(otherSign1)) {
                    continue;
                }
                SignIn signIn1 = new SignIn();
                BeanUtils.copyProperties(otherSign1, signIn1);
                otherSign1.setSignStatus(switchSignStatus(signIn1));

                if (Objects.isNull(otherSign)) {
                    otherSign = otherSign1;
                    otherTagetSign = signIn1;
                } else if (Objects.nonNull(otherSign.getExType()) && Objects.nonNull(otherSign1.getExType()) && Objects.nonNull(otherSign1.getSignStatus()) && Objects.nonNull(otherSign.getSignStatus())
                        && otherSign1.getSignStatus() > otherSign.getSignStatus()) {
                    otherSign = otherSign1;
                    otherTagetSign = signIn1;
                } else if (Objects.nonNull(otherSign.getExType()) && Objects.nonNull(otherSign1.getExType()) && Objects.nonNull(otherSign1.getSignStatus()) && Objects.isNull(otherSign.getSignStatus())) {
                    otherSign = otherSign1;
                    otherTagetSign = signIn1;
                }
            }


            LineInfo.PersonInfoVo personInfoVo = combationPersonInfoVo(otherDriver, otherTagetSign);
            setDriverByPost(otherDriver, lineInfo, personInfoVo);
        }

        return lineInfo;
    }

    private LineInfo.PersonInfoVo combationPersonInfoVo(Driver driver, SignIn signIn) {
        LineInfo.PersonInfoVo personInfoVo = new LineInfo.PersonInfoVo();
        personInfoVo.setName(driver.getPersonnelName());

        personInfoVo.setSignStatus(switchSignStatus(signIn));
        personInfoVo.setPosts(driver.getPosts());

        return personInfoVo;
    }

    private Integer switchSignStatus(SignIn signIn) {
        if (Objects.isNull(signIn.getExType())) {
            return null;
        }
        if (isSignStatusWineEnum(signIn)) {
            return SignStatusEnum.SIGN_STATUS_WINE_ENUM.getStatus();
        }

        if (isSignStatusDelayEnum(signIn)) {
            return SignStatusEnum.SIGN_STATUS_DELAY_ENUM.getStatus();
        }

        if (isSignStatusZoneEnum(signIn)) {
            return SignStatusEnum.SIGN_STATUS_ZONE_ENUM.getStatus();
        }
        return SignStatusEnum.SIGN_STATUS_EMPTY_ENUM.getStatus();

    }

    private void setDriverByPost(Driver driver, LineInfo lineInfo, LineInfo.PersonInfoVo personInfoVo) {
        if (isDriver(driver)) {
            lineInfo.setDriverInfoVo(personInfoVo);
        } else {
            lineInfo.setDriverInfoVo(personInfoVo);
        }
    }

    private <T> List<T> getRedisData(String key, String dateStr, Class<T> calzz) {
        key = MessageFormat.format(key, dateStr, "*");
        List<String> jsonStrs = redisCache.getCacheList(key);
        if (CollectionUtils.isEmpty(jsonStrs)) {
            return Collections.emptyList();
        }
        return jsonStrs.stream().map(json -> {
            T t = JSON.parseObject(json, calzz);
            return t;
        }).collect(Collectors.toList());
    }

    private List<FleetInfoVo> getFleetInfoVoBtRedis(String key) {
        try {
            String json = redisCache.getCacheObject(key);
            if (StringUtils.isEmpty(json)) {
                return Collections.emptyList();
            }
            return JSON.parseArray(json, FleetInfoVo.class);
        } catch (Exception e) {
            log.error("[{}]从redis中获取页面数据异常", key, e);
        }
        return Collections.emptyList();
    }

    private List<FleetInfoVo> combationFleetInfoVoBtRedis(String redisKey, String dateStr) {

        String key = MessageFormat.format(LINE_SIGN_REPORT_FLEET_KEY, dateStr);
        List<FleetInfoVo> fleetInfoVos = getFleetInfoVoOfRedis(key);
        if (CollectionUtils.isEmpty(fleetInfoVos)) {
            fleetInfoVos = combationFleetInfoVo(key);
        }

        if (CollectionUtils.isEmpty(fleetInfoVos)) {
            return Collections.emptyList();
        }
        List<LineInfo> lineInfoList = getRedisData(LINE_SIGN_NBBM_KEY, dateStr, LineInfo.class);
        List<FleetState> fleetStates = getRedisData(LINE_SIGN_STATUS_KEY, dateStr, FleetState.class);

        int lineInfoListSize = CollectionUtils.size(lineInfoList);
        int fleetStatesSize = CollectionUtils.size(fleetStates);

        fleetInfoVos = fleetInfoVos.stream().map(fv -> {
            if (lineInfoListSize > 0) {
                if (CollectionUtils.isNotEmpty(fv.getFleetInfos())) {
                    List<FleetInfoVo.FleetInfo> fleetInfos = fv.getFleetInfos().stream().map(fi -> {
                        List<LineInfo> lineInfos = lineInfoList.stream().filter(l -> Objects.equals(fv.getTitle(), l.getFleetName()) &&
                                Objects.equals(fi.getLineName(), l.getLineName())).collect(Collectors.toList());
                        if (CollectionUtils.isNotEmpty(lineInfos)) {
                            fi.setLineInfos(lineInfos);
                        }
                        return fi;
                    }).collect(Collectors.toList());

                    fv.setFleetInfos(fleetInfos);
                }
            }

            if (fleetStatesSize > 0) {
                List<FleetState> fss = fleetStates.stream().filter(fs -> Objects.equals(fs.getFleetName(), fv.getTitle())).collect(Collectors.toList());
                if (CollectionUtils.isNotEmpty(fss)) {
                    fv.setFleetStates(fss);
                }
            }
            return fv;
        }).collect(Collectors.toList());

        redisCache.setCacheObject(redisKey, JSON.toJSONString(fleetInfoVos), 10, TimeUnit.SECONDS);
        return fleetInfoVos;
    }

}