添加重置测试点接口

whycxzp

2021-06-03 0ed39bd9a35a51a118f54b6c3fea792294431a2f

 src/main/java/com/whyc/service/ExperimentService.java

@@ -1,9 +1,11 @@
package com.whyc.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.whyc.constant.ExperimentType;
import com.whyc.dto.ExperimentConditionDTO;
import com.whyc.dto.Response;
import com.whyc.mapper.*;
@@ -11,6 +13,7 @@
import com.whyc.pojo.ExperimentBaseDataKZ;
import com.whyc.pojo.ExperimentPoint;
import com.whyc.pojo.ExperimentPrecondition;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@@ -26,6 +29,7 @@
import static java.lang.Thread.sleep;

@Service
@Slf4j
public class ExperimentService {

    @Resource
@@ -40,14 +44,27 @@
    private CommonMapper commonMapper;

    public Response exist() {
        QueryWrapper<Experiment> wrapper = Wrappers.query();
        wrapper.eq("status",1);
        List<Experiment> experiments = mapper.selectList(wrapper);
        ExperimentConditionDTO condition = new ExperimentConditionDTO();
        condition.setStatus(1);
        List<Experiment> experiments = mapper.getList(condition);
        //不存在试验
        if (experiments.isEmpty()){
            return new Response().set(-1,"暂无试验");
            return new Response().setMsg(-1,"暂无试验");
        }
        return new Response().set(1,experiments);
        Experiment experiment = experiments.get(0);
        String url = null;
        if (experiment.getId().toLowerCase().contains(ExperimentType.KZ.getValue())){
            url = "noLoadTest";
        }
        else if(experiment.getId().toLowerCase().contains(ExperimentType.FZ.getValue())){
            url = "loadTest";
        }
        else if(experiment.getId().toLowerCase().contains(ExperimentType.RZ.getValue())){
            url = "windingTest";
        }else{
            url ="不存在呀";
        }
        return new Response().set(1,experiments.get(0),url);
    }

    /**
@@ -92,7 +109,7 @@
    }

    @Transactional
    public Response addKZ(Experiment experiment) {
    public Response addKZFZ(Experiment experiment) {
        //插入experiment数据
        experiment.setCreateTime(new Date());
        //新增初始化状态为0未开始,正在进行
@@ -103,10 +120,9 @@
        kzMapper.insert((ExperimentBaseDataKZ) experiment.getBaseData());

        //插入experiment_point数据
        ExperimentPoint point = (ExperimentPoint) experiment.getPoint();
        point.setStatus(1);
        pointMapper.insert(point);

        List<ExperimentPoint> points = (List<ExperimentPoint>) experiment.getPoint();
        points.stream().forEach(p->p.setStatus(0));
        pointMapper.insertBatchSomeColumn(points);
        //TODO 插入紧急停止数据

        return new Response().setMsg(1,"新增成功");
@@ -122,7 +138,7 @@
        //2种方式
        //m1
        QueryWrapper<ExperimentPrecondition> wrapper = Wrappers.query();
        wrapper.eq("type",type);
        wrapper.eq("type",type).eq("flag",1);
        List<ExperimentPrecondition> preconditions = preconditionMapper.selectList(wrapper);
        preconditions.stream().forEach(precondition->{
            //获取对应的值
@@ -130,14 +146,33 @@
            precondition.setActualValue(preconditionStatus.getActualValue());
            precondition.setStatus(preconditionStatus.getStatus());*/
            Object preconditionActualValue = commonMapper.getPreconditionStatus(precondition);
            String preconditionActualValueStr = preconditionActualValue.toString();
            if(precondition.getValue().equals(preconditionActualValueStr)){
                precondition.setStatus(1);
            }else{
                precondition.setStatus(0);
                code.set(-1);
            /*String preconditionActualValueStr = preconditionActualValue.toString();
            if(precondition.getValue().equals(preconditionActualValueStr)){*/
            //采用浮点/整型进行数值对比
            if(preconditionActualValue instanceof Integer) {
                Integer actualValue = (Integer) preconditionActualValue;
                Integer defaultValue = Integer.parseInt(precondition.getValue());

                if (defaultValue.equals(actualValue)) {
                    precondition.setStatus(1);
                } else {
                    precondition.setStatus(0);
                    code.set(-1);
                }
                precondition.setActualValue(actualValue.toString());
            }
            precondition.setActualValue(preconditionActualValueStr);
            else if(preconditionActualValue instanceof Float) {
                Float actualValue = (Float) preconditionActualValue;
                Float defaultValue = Float.parseFloat(precondition.getValue());

                if (defaultValue.equals(actualValue)) {
                    precondition.setStatus(1);
                } else {
                    precondition.setStatus(0);
                    code.set(-1);
                }
                precondition.setActualValue(actualValue.toString());
            }
        });
        return new Response().set(code.get(),preconditions);
    }
@@ -145,7 +180,8 @@
    /**
     * 检查中置条件-当前功率和当前定子温度,如果符合标准,返回当前值
     */
    public Response checkPreconditionStep1(String type){
    public Response checkPreconditionStep1(String experimentId){
        String type = experimentId.split("_")[0].toLowerCase();
        QueryWrapper<ExperimentPrecondition> wrapper = Wrappers.query();
        wrapper.eq("type",type+"_1");
        List<ExperimentPrecondition> preconditions = preconditionMapper.selectList(wrapper);
@@ -159,18 +195,40 @@
            preconditions.stream().forEach(precondition -> {
                //获取对应的值
                Object preconditionActualValue = commonMapper.getPreconditionStatus(precondition);
                //采用浮点进行数值对比
                Float actualValue = (Float) preconditionActualValue;
                Float defaultValue = Float.parseFloat(precondition.getValue());
                //采用浮点/整型进行数值对比
                if(preconditionActualValue instanceof Float) {
                    Float actualValue = (Float) preconditionActualValue;
                    Float defaultValue = Float.parseFloat(precondition.getValue());

                if (defaultValue.equals(actualValue)) {
                    //条件达成,达成数上+1
                    passNum.set(passNum.get()+1);
                    //记录当前值
                    precondition.setActualValue(actualValue.toString());
                    if (defaultValue.equals(actualValue)) {
                        //条件达成,达成数上+1
                        passNum.set(passNum.get() + 1);
                        //记录当前值
                        precondition.setActualValue(actualValue.toString());
                    }
                }
                //采用浮点/整型进行数值对比
                if(preconditionActualValue instanceof Integer) {
                    Integer actualValue = (Integer) preconditionActualValue;
                    Integer defaultValue = Integer.parseInt(precondition.getValue());

                    if (defaultValue.equals(actualValue)) {
                        //条件达成,达成数上+1
                        passNum.set(passNum.get() + 1);
                        //记录当前值
                        precondition.setActualValue(actualValue.toString());
                    }
                }
            });
        }
        //演示需要
        try {
            sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //设置试验整体状态为1,启动时间更新
        mapper.updateStatusAndTime(experimentId,1,"start_time",new Date());
        return new Response().set(1,preconditions);
    }

@@ -193,6 +251,14 @@
        QueryWrapper<ExperimentPoint> wrapper = Wrappers.query();
        wrapper.eq("experiment_id",experimentId);
        List<ExperimentPoint> experimentPoints = pointMapper.selectList(wrapper);
        /*//TODO 针对已完成的测试点,计算出这段时间内的平均功率并返回,需要考虑是否将功率字段持久化到表中
        experimentPoints.stream().forEach(point -> {
            if(point.getStatus()==2){
                //计算出平均功率并赋值
                int power = (int) (100 + Math.random() * 10);
                point.setAveragePower(power);
            }
        });*/
        return new Response<List<ExperimentPoint>>().set(1,experimentPoints);
    }

@@ -200,40 +266,142 @@
     * 更新测试点的开始时间和状态
     */
    public Response updatePointStatus(ExperimentPoint experimentPoint){
        pointMapper.update(experimentPoint,null);
        pointMapper.updateById(experimentPoint);
        return new Response().set(1,"状态更新成功");
    }

    /**
     * 启动测试点,并在测试时长过后,返回测试结果
     * 测试点的结束,结束分两种情况:
     *  情况一:经过预定的测试时长,停止
     *  情况二:更新了数据库的某个字段,代码循环判断这个字段,如果为2则停止实验并返回结果
     * @return
     */
    public Response startExperimentPoint(ExperimentPoint point){
        //更新测试时间和测试点状态
        point.setStartTime(new Date());
        point.setStatus(1);
        pointMapper.update(point,null);
        pointMapper.updateById(point);
        //等待duration时间
        Integer duration = point.getDuration();
        Integer durationSecond = duration*60;
        try {
            sleep(durationSecond);
        final boolean[] threadStatus = {true};
        //采用线程的原因是非线程sleep后无法执行手动结束条件判断代码
        Thread t = new Thread(){
            @Override
            public void run() {
                try {
                    sleep(durationSecond*1000);
                    threadStatus[0] = false;
                } catch (InterruptedException e) {
                    interrupt();
                    log.warn("t1线程被打断");
                    //e.printStackTrace();
                }
            };
        };
        t.start();

        boolean statusFlag =true;
        //手动停止和测试点预设时间,1个条件成立就终止测试
        while(statusFlag && threadStatus[0]){
            //查询测试点状态是否被打断
            QueryWrapper<ExperimentPoint> wrapper = Wrappers.query();
            wrapper.select("status").eq("id",point.getId());
            ExperimentPoint currentPoint = pointMapper.selectOne(wrapper);
            if(currentPoint.getStatus()==3){
                statusFlag = false;
            }
        }
        log.warn("测试点结束");
        if (t.isAlive()) {
            t.interrupt();
        }

        /*try {
            //sleep(durationSecond);
            //演示需要,使用5s
            sleep(5000);

        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        }*/
        pointMapper.updateEndTime(point.getId(),new Date());
        //返回这段时间的测试结果
        Map<String,String> resMap = new HashMap<>();
        //TODO 这段时间内的数据,需要进行动态计算
        int value = (int) (100 + Math.random() * 10);
        resMap.put("平均功率",value+"kW");
        return new Response().set(1,resMap);
        ExperimentPoint pointTemp = new ExperimentPoint();
        pointTemp.setId(point.getId());
        pointTemp.setAveragePower(value);
        pointMapper.updateById(pointTemp);
        return new Response().setMsg(1,"测试点结束");
    }


    public Response finishExperiment(String experimentId) {
        mapper.updateStatusAndTime(experimentId,2,"end_time",new Date());
        return new Response().setMsg(1,"状态更新成功");
    }

    public Response finishExperimentPoint(Integer id) {
        ExperimentPoint point = new ExperimentPoint();
        point.setId(id);
        //中断信号
        point.setStatus(3);
        pointMapper.updateById(point);
        return new Response().setMsg(1,"测试点中断信号更新成功");
    }

    public Response restartExperimentPoint(Integer id) {
        ExperimentPoint point = new ExperimentPoint();
        point.setId(id);
        point.setStatus(0);
        point.setStartTime(null);
        point.setEndTime(null);
        pointMapper.updateById(point);
        return new Response().setMsg(1,"重置测试点成功");
    }

    public Response setPrecondition(Integer id,Integer value) {
        switch (id){
            case 1:{
                commonMapper.setPrecondition("`db_3.5mw_motor`.tb_central_monitor_sys_rt","10001","switch_close",value.toString());
                break;
            }
            case 2:{
                commonMapper.setPrecondition("`db_3.5mw_motor`.tb_rectifier_power_rt","30001","rectifier_vol",value.toString());
                break;
            }
            case 3:{
                commonMapper.setPrecondition("`db_3.5mw_motor`.tb_central_monitor_sys_st","10005","vol_a",value.toString());
                break;
            }
            case 4:{
                commonMapper.setPrecondition("`db_3.5mw_motor`.tb_central_monitor_sys_st","10005","vol_b",value.toString());
                break;
            }
            case 5:{
                commonMapper.setPrecondition("`db_3.5mw_motor`.tb_device_state","40001","comm_status",value.toString());
                break;
            }
            case 6:{
                commonMapper.setPrecondition("`db_3.5mw_motor`.tb_device_state","40002","comm_status",value.toString());
                break;
            }
            case 7:{
                commonMapper.setPrecondition("`db_3.5mw_motor`.tb_device_state","50001","comm_status",value.toString());
                break;
            }
        }
        return new Response().setMsg(1,"设置完成");
    }

    /*======History======*/

    public Response<PageInfo<Experiment>> getPage(Integer pageNum, Integer pageSize, ExperimentConditionDTO condition) {
        condition.setStatus(2);
        PageHelper.startPage(pageNum,pageSize);
        List<Experiment> experimentList = mapper.getPage(condition);
        List<Experiment> experimentList = mapper.getList(condition);
        //查询结果的duration是分钟,转换为 x时x分格式
        experimentList.stream().forEach(experiment -> {
            int duration = Integer.parseInt(experiment.getDuration());