潘钊 / bsth_control · Files

package com.bsth.service.schedule.impl;

import com.bsth.entity.Line;
import com.bsth.entity.schedule.SchedulePlan;
import com.bsth.entity.schedule.SchedulePlanInfo;
import com.bsth.entity.schedule.TTInfo;
import com.bsth.entity.schedule.rule.ScheduleRule1Flat;
import com.bsth.repository.BusinessRepository;
import com.bsth.repository.LineRepository;
import com.bsth.repository.schedule.*;
import com.bsth.service.schedule.SchedulePlanService;
import com.bsth.service.schedule.exception.ScheduleException;
import com.bsth.service.schedule.rules.ScheduleRuleService;
import com.bsth.service.schedule.rules.plan.PlanCalcuParam_input;
import com.bsth.service.schedule.rules.plan.PlanResult;
import com.bsth.service.schedule.rules.rerun.RerunRule_input;
import com.bsth.service.schedule.rules.rerun.RerunRule_param;
import com.bsth.service.schedule.rules.shiftloop.ScheduleCalcuParam_input;
import com.bsth.service.schedule.rules.shiftloop.ScheduleResults_output;
import com.bsth.service.schedule.rules.shiftloop.ScheduleRule_input;
import com.bsth.service.schedule.rules.ttinfo.*;
import com.bsth.service.schedule.rules.ttinfo2.CalcuParam;
import com.bsth.service.schedule.rules.ttinfo2.Result;
import com.bsth.service.schedule.rules.validate.ValidateParam;
import com.bsth.service.schedule.rules.validate.ValidateResults_output;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.kie.api.KieBase;
import org.kie.api.runtime.KieSession;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * Created by xu on 16/6/16.
 */
@Service
public class SchedulePlanServiceImpl extends BServiceImpl<SchedulePlan, Long> implements SchedulePlanService {
    @Autowired
    private KieBase kieBase;
    @Autowired
    private ScheduleRule1FlatRepository scheduleRule1FlatRepository;
    @Autowired
    private TTInfoRepository ttInfoRepository;
    @Autowired
    private TTInfoDetailRepository ttInfoDetailRepository;
    @Autowired
    private LineRepository lineRepository;
    @Autowired
    private CarConfigInfoRepository carConfigInfoRepository;
    @Autowired
    private EmployeeConfigInfoRepository employeeConfigInfoRepository;
    @Autowired
    private BusinessRepository businessRepository;
    @Autowired
    private ScheduleRuleService scheduleRuleService;

    /** 日志记录器 */
    private Logger logger = LoggerFactory.getLogger(SchedulePlanServiceImpl.class);

    /**
     * 循环规则输出。
     * @param schedulePlan 排班计划对象
     * @param lpInfoResults_output 时刻表每日路牌的情况
     */
    private ScheduleResults_output loopRuleOutput(
            SchedulePlan schedulePlan,
            LpInfoResults_output lpInfoResults_output) {
        // 1-1、构造drools规则输入数据，输出数据
        // 全局计算参数
        ScheduleCalcuParam_input scheduleCalcuParam_input = new ScheduleCalcuParam_input(schedulePlan);
        // 每个规则对应的输入参数
        List<ScheduleRule_input> scheduleRule_inputs = new ArrayList<>();
        List<ScheduleRule1Flat> scheduleRule1Flats = scheduleRule1FlatRepository.findByXl(schedulePlan.getXl());

        for (ScheduleRule1Flat scheduleRule1Flat: scheduleRule1Flats) {
            ScheduleRule_input scheduleRule_input = new ScheduleRule_input(scheduleRule1Flat);
            scheduleRule_inputs.add(scheduleRule_input);
        }

        // 规则输出数据
        ScheduleResults_output scheduleResults_output = new ScheduleResults_output();

        // 1-2、构造drools session->载入数据->启动规则->计算->销毁session
        // 创建session，内部配置的是stateful
        KieSession session = kieBase.newKieSession();
        // 设置gloable对象，在drl中通过别名使用
        session.setGlobal("scheduleResult", scheduleResults_output);
        session.setGlobal("log", logger); // 设置日志
        session.setGlobal("scheduleRuleService", scheduleRuleService);

        // 载入数据
        session.insert(scheduleCalcuParam_input);
        for (ScheduleRule_input scheduleRule_input : scheduleRule_inputs) {
            session.insert(scheduleRule_input);
        }
        // 每日时刻表路牌数据
        for (LpInfoResult_output lpInfoResult_output: lpInfoResults_output.getLpInfoResult_outputs()) {
            session.insert(lpInfoResult_output);
        }
        // 执行rule
        session.fireAllRules();

        // 执行完毕销毁，有日志的也要关闭
        session.dispose();

        // 保存循环规则结果数据
        scheduleRuleService.generateRuleResult(scheduleResults_output.getSchedulePlanRuleResults());

//        logger.info("循环规则输出={}", scheduleResults_output.showGuideboardDesc1());

        return scheduleResults_output;
    }

    /**
     * 时刻表选择（判定每天使用的时刻表，以及路牌数据输出）。
     * @param schedulePlan 排班计划对象
     * @return TTInfoResults_output, LpInfoResults_output
     */
    private Object[] ttInfoOutput(SchedulePlan schedulePlan) {
        // 获取线路的所有未作废的时刻表
        List<TTInfo> ttInfos = ttInfoRepository.findInCanceledByXl(schedulePlan.getXl());

        // 1-1、构造drools规则输入数据，输出数据
        // 全局计算参数
        TTInfoCalcuParam_input ttInfoCalcuParam_input =
                new TTInfoCalcuParam_input(
                        new DateTime(schedulePlan.getScheduleFromTime()),
                        new DateTime(schedulePlan.getScheduleToTime()),
                        String.valueOf(schedulePlan.getXl().getId())
                );
        // 规则输出数据
        TTInfoResults_output ttInfoResults_output = new TTInfoResults_output();
        LpInfoResults_output lpInfoResults_output = new LpInfoResults_output();

        // 1-2、构造drools session->载入数据->启动规则->计算->销毁session
        // 创建session，内部配置的是stateful
        KieSession session = kieBase.newKieSession();

        // 设置gloable对象，在drl中通过别名使用
        session.setGlobal("results", ttInfoResults_output);
        session.setGlobal("lpInfoResults_output", lpInfoResults_output);
        session.setGlobal("log", logger); // 设置日志
        session.setGlobal("tTInfoDetailRepository", ttInfoDetailRepository);

        // 载入数据
        session.insert(ttInfoCalcuParam_input);
        for (TTInfo ttInfo : ttInfos) {
            TTInfo_input ttInfo_input = new TTInfo_input(ttInfo);
            session.insert(ttInfo_input);
        }

        // 载入数据2（计算规则最早启用时间）
        List<ScheduleRule1Flat> scheduleRule1Flats = scheduleRule1FlatRepository.findByXl(schedulePlan.getXl());

        for (ScheduleRule1Flat scheduleRule1Flat: scheduleRule1Flats) {
            ScheduleRule_input scheduleRule_input = new ScheduleRule_input(scheduleRule1Flat);
            session.insert(scheduleRule_input);
        }

        // 执行rule
        session.fireAllRules();

        // 执行完毕销毁，有日志的也要关闭
        session.dispose();

        return new Object[] {ttInfoResults_output, lpInfoResults_output};

    }

    /**
     * 排班生成。
     * @param schedulePlan 排班计划对象
     * @param scheduleResults_output loopRuleOutput方法规则输出
     * @param ttInfoResults_output ttInfoOutput方法规则输出
     * @return PlanResult
     */
    private PlanResult planResultOutput(
            SchedulePlan schedulePlan,
            ScheduleResults_output scheduleResults_output,
            TTInfoResults_output ttInfoResults_output) {

        // 1-1、构造drools规则输入数据，输出数据
        PlanCalcuParam_input planCalcuParam_input = new PlanCalcuParam_input(
                schedulePlan,
                scheduleResults_output,
                ttInfoResults_output
        );
        // 规则输出数据
        PlanResult planResult = new PlanResult();
        planResult.setXlId(schedulePlan.getXl().getId().toString());

        // 1-2、构造drools session->载入数据->启动规则->计算->销毁session
        // 创建session，内部配置的是stateful
        KieSession session = kieBase.newKieSession();

        // 设置gloable对象，在drl中通过别名使用
        session.setGlobal("planResult", planResult);
        session.setGlobal("log", logger); // 设置日志

        session.setGlobal("tTInfoDetailRepository", ttInfoDetailRepository);
        session.setGlobal("carConfigInfoRepository", carConfigInfoRepository);
        session.setGlobal("employeeConfigInfoRepository", employeeConfigInfoRepository);
        session.setGlobal("lineRepository", lineRepository);
        session.setGlobal("businessRepository", businessRepository);

        // 载入数据
        session.insert(planCalcuParam_input);

        // 执行rule
        session.fireAllRules();

        // 执行完毕销毁，有日志的也要关闭
        session.dispose();

        return planResult;

    }

    /**
     * 生成线路排班（不含套跑规则）。
     * @param schedulePlan
     * @return
     */
    private PlanResult schedulePlanWithOutRerun(SchedulePlan schedulePlan) {
        // 1、时刻表数据及每日路牌数据计算
        Date start1 = new Date();
        Object[] ttInfoRets = ttInfoOutput(schedulePlan);
        TTInfoResults_output ttInfoResults_output = (TTInfoResults_output) ttInfoRets[0];
        LpInfoResults_output lpInfoResults_output = (LpInfoResults_output) ttInfoRets[1];
        Date end1 = new Date();
        // 2、循环规则计算输出
        Date start2 = new Date();
        ScheduleResults_output scheduleResults_output = loopRuleOutput(schedulePlan, lpInfoResults_output);
        Date end2 = new Date();
        // 3、计划输出
        Date start3 = new Date();
        PlanResult planResult = planResultOutput(schedulePlan, scheduleResults_output, ttInfoResults_output);
        Date end3 = new Date();

        logger.info("drool时刻表每日路牌计算 {} ms，drool循环规则计算 {} ms，drool计划数据 {} ms",
                end1.getTime() - start1.getTime(),
                end2.getTime() - start2.getTime(),
                end3.getTime() - start3.getTime());

        // TODO：将lpInfoResults_output 也要返回

        return planResult;
    }

    /**
     * 套跑计划排班数据。
     * @param planResult
     */
    private void rerunPlanResult(PlanResult planResult, SchedulePlan schedulePlan) {
        List<RerunRule_input> rerunRule_inputs = scheduleRuleService.findRerunrule(Integer.parseInt(planResult.getXlId()));
        logger.info("套跑数量 {} 组", rerunRule_inputs.size());

        // 主线路id
        Integer mainXlId = schedulePlan.getXl().getId();

        if (rerunRule_inputs.size() > 0) {
            // 找出是对应路牌类型的线路，计算循环规则输出
            Set<String> xlids = new HashSet<>();
            for (RerunRule_input rerunRule_input: rerunRule_inputs) {
                if ("dylp".equals(rerunRule_input.getType())) {
                    xlids.add(rerunRule_input.getS_xl()); // 参与套跑的线路
                }
            }

            List<ScheduleResults_output> scheduleResults_outputs = new ArrayList<>();
            Date start1 = new Date();
            for (String xlid: xlids) {
                schedulePlan.getXl().setId(Integer.parseInt(xlid)); // 套跑的线路默认跟着主线路设定走
                // 获取套跑线路的循环规则计算输出
                Object[] ttInfoRets = ttInfoOutput(schedulePlan);
                LpInfoResults_output lpInfoResults_output = (LpInfoResults_output) ttInfoRets[1];
                ScheduleResults_output scheduleResults_output = loopRuleOutput(schedulePlan, lpInfoResults_output);
                scheduleResults_outputs.add(scheduleResults_output);
            }

            // 1-2、构造drools session->载入数据->启动规则->计算->销毁session
            // 创建session，内部配置的是stateful
            KieSession session = kieBase.newKieSession();

            // 设置gloable对象，在drl中通过别名使用
            session.setGlobal("planResult", planResult);
            session.setGlobal("log", logger); // 设置日志

            session.setGlobal("carConfigInfoRepository", carConfigInfoRepository);
            session.setGlobal("employeeConfigInfoRepository", employeeConfigInfoRepository);

            // 载入数据
            RerunRule_param rerunRule_param = new RerunRule_param();
            rerunRule_param.setMxlid(planResult.getXlId());
            rerunRule_param.setXlIds_dylp(xlids);
            session.insert(rerunRule_param);
            for (RerunRule_input rri: rerunRule_inputs) {
                session.insert(rri);
            }
            for (SchedulePlanInfo spi: planResult.getSchedulePlanInfos()) {
                session.insert(spi);
            }
            for (ScheduleResults_output sro: scheduleResults_outputs) {
                session.insert(sro);
            }

            // 执行rule
            session.fireAllRules();

            // 执行完毕销毁，有日志的也要关闭
            session.dispose();

            Date end1 = new Date();
            logger.info("套跑规则计算，耗时 {} ms", end1.getTime() - start1.getTime());

            schedulePlan.getXl().setId(mainXlId);

        }

    }

    /**
     * 验证排班结果。
     * @param planResult
     * @param schedulePlan
     */
    public void validPlanResult(PlanResult planResult, SchedulePlan schedulePlan) {
        // 1-1、构造drools规则输入数据，输出数据
        ValidateParam validateParam = new ValidateParam(
                new DateTime(schedulePlan.getScheduleFromTime()),
                new DateTime(schedulePlan.getScheduleToTime())
        );
        // 规则输出数据
        ValidateResults_output result = new ValidateResults_output();

        // 1-2、构造drools session->载入数据->启动规则->计算->销毁session
        // 创建session，内部配置的是stateful
        KieSession session = kieBase.newKieSession();

        // 设置gloable对象，在drl中通过别名使用
        session.setGlobal("validResult", result);
        session.setGlobal("log", logger); // 设置日志

        // 载入数据
        session.insert(validateParam);
        for (SchedulePlanInfo schedulePlanInfo: planResult.getSchedulePlanInfos()) {
            session.insert(schedulePlanInfo);
        }

        // 执行rule
        session.fireAllRules();

        // 执行完毕销毁，有日志的也要关闭
        session.dispose();

//        logger.info("错误总数={}", result.getInfos().size());
//        for (ValidateResults_output.ValidInfo validInfo: result.getInfos()) {
//            logger.info(validInfo.getDesc());
//        }

        // 取10条错误
        int size = result.getInfos().size() > 10 ? 10: result.getInfos().size();
        List<String> desclist = new ArrayList<>();
        for (int i = 0; i < size; i++) {
            desclist.add(result.getInfos().get(i).getDesc());
        }
        if (desclist.size() > 0) {
            schedulePlan.setPlanResult(StringUtils.join(desclist, "</br>"));
        } else {
            schedulePlan.setPlanResult("ok");
        }

        // TODO：设定错误信息
    }

    @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.READ_COMMITTED)
    public SchedulePlan save(SchedulePlan schedulePlan) {
        // pre、如果排班的数据之前已经有了，删除之前的数据
        Date startpre = new Date();
        scheduleRuleService.deelteSchedulePlanInfo(
                schedulePlan.getXl().getId(),
                schedulePlan.getScheduleFromTime(),
                schedulePlan.getScheduleToTime());
        Date endpre = new Date();

        // 1、查找线路，这是主线路
        Line xl = lineRepository.findOne(schedulePlan.getXl().getId());
        logger.info("<--- 排班master线路 id={}, name={}, 开始排班", xl.getId(), xl.getName());

        // 2、确定主线路排班（无套跑规则）
        PlanResult planResult = schedulePlanWithOutRerun(schedulePlan);

        // 3、确定套跑规则
        rerunPlanResult(planResult, schedulePlan);

        // TODO：3-1、验证排班结果
        validPlanResult(planResult, schedulePlan);

        // 4、保存数据（jdbcTemplate 批量插入）
        Date start4 = new Date();
        scheduleRuleService.generateSchedulePlan(schedulePlan, planResult.getSchedulePlanInfos());
        Date end4 = new Date();

        logger.info("删除数据 {} ms，保存主线路数据 {} 条 耗时 {} ms --->",
                endpre.getTime() - startpre.getTime(),
                planResult.getSchedulePlanInfos().size(),
                end4.getTime() - start4.getTime());

        return new SchedulePlan();
    }

    @Override
    public void delete(Long aLong) throws ScheduleException {
        scheduleRuleService.deleteSchedulePlanAll(aLong);
    }

    @Override
    public SchedulePlan findSchedulePlanTommorw() {
        DateTime today = new DateTime(new Date());
        DateTime tommorw = new DateTime(today.getYear(), today.getMonthOfYear(), today.getDayOfMonth(), 0, 0).plusDays(1);
        Map<String, Object> param = new HashMap<>();
        param.put("scheduleFromTime_le", tommorw.toDate());
        param.put("scheduleToTime_ge", tommorw.toDate()     );
        Iterator<SchedulePlan> schedulePlanIterator = this.list(param).iterator();
        if (schedulePlanIterator.hasNext()) {
            return schedulePlanIterator.next();
        }
        return null;
    }

    @Override
    public Result validateTTInfo(Integer xlid, Date from, Date to) {
        // 构造drools session->载入数据->启动规则->计算->销毁session
        // 创建session，内部配置的是stateful
        KieSession session = kieBase.newKieSession();
        // 设置gloable对象，在drl中通过别名使用
        session.setGlobal("log", logger);
        session.setGlobal("lineRepository", lineRepository);
        session.setGlobal("tTInfoDetailRepository", ttInfoDetailRepository);

        Result rs = new Result(); // 输出gloable对象
        session.setGlobal("rs", rs);

        // 载入数据
        CalcuParam calcuParam = new CalcuParam(
                new DateTime(from), new DateTime(to), xlid);
        session.insert(calcuParam);
        List<TTInfo> ttInfos = (List<TTInfo>) ttInfoRepository.findAll();
        for (TTInfo ttInfo: ttInfos)
                session.insert(ttInfo);

        // 执行rule
        session.fireAllRules();

        // 执行完毕销毁，有日志的也要关闭
        session.dispose();


        return rs;
    }
}