更新试验接口

whycxzp

2021-05-20 3da521b9e0a86dd9cc0bb28b2dfa0e7084ffc00f

更新试验接口

 src/main/java/com/whyc/controller/ExperimentController.java

@@ -21,6 +21,12 @@
    @Autowired
    private ExperimentService service;

    @GetMapping("exist")
    @ApiOperation(value = "查询是否当前有试验",notes = "如果有,code=1,返回试验的基础数据;如果没有,code=-1")
    public Response exist(){
        return service.exist();
    }

    @GetMapping("experimentId")
    @ApiOperation(value = "查询当前试验编号",notes = "传入的type选择其一:" +
            "绕组:rz,\n" +
@@ -57,7 +63,30 @@
        return service.checkPrecondition(type);
    }

    /**
     * 开始试验,请求接口1,获取试验测试点
     */
    @GetMapping("point")
    @ApiOperation(value = "查询测试点列表")
    public Response getPoint(@RequestParam String experimentId){
        return service.getPoint(experimentId);
    }

    /**
     * 开始试验,检查中置条件
     * @return
     */
    @GetMapping("checkPreconditionStep1")
    @ApiOperation(value = "步骤1,检查升温情况")
    public Response checkPreconditionStep1(@RequestParam String experimentId){
        return service.checkPreconditionStep1(experimentId);
    }

    @PostMapping("startExperimentPoint")
    @ApiOperation(value = "启动测试点")
    public Response StartExperimentPoint(@RequestBody ExperimentPoint point){
        return service.startExperimentPoint(point);
    }

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


 src/main/java/com/whyc/mapper/ExperimentPointMapper.java

@@ -1,6 +1,11 @@
package com.whyc.mapper;

import com.whyc.pojo.ExperimentPoint;
import org.apache.ibatis.annotations.Update;

import java.util.Date;

public interface ExperimentPointMapper extends CustomMapper<ExperimentPoint>{
    @Update("update `db_3.5mw_web`.tb_experiment_point set end_time = #{date} where id = #{id}")
    Integer updateEndTime(Integer id, Date date);
}

 src/main/java/com/whyc/pojo/Experiment.java

@@ -47,7 +47,7 @@
    @ApiModelProperty("创建时间")
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss",timezone = "Asia/Shanghai")
    private Date createTime;
    @ApiModelProperty("状态:0-取消,1-进行中,2-完成")
    @ApiModelProperty("状态:-1-取消,0-未开始,1-进行中,2-完成")
    private Integer status;
    @ApiModelProperty("基础数据")
    @TableField(exist = false)

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

@@ -4,7 +4,6 @@
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.*;
@@ -18,8 +17,13 @@
import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;

import static java.lang.Thread.sleep;

@Service
public class ExperimentService {
@@ -34,6 +38,17 @@
    private ExperimentPreconditionMapper preconditionMapper;
    @Resource
    private CommonMapper commonMapper;

    public Response exist() {
        QueryWrapper<Experiment> wrapper = Wrappers.query();
        wrapper.eq("status",1);
        List<Experiment> experiments = mapper.selectList(wrapper);
        //不存在试验
        if (experiments.isEmpty()){
            return new Response().set(-1,"暂无试验");
        }
        return new Response().set(1,experiments);
    }

    /**
     * 绕组:rz,
@@ -80,8 +95,8 @@
    public Response addKZ(Experiment experiment) {
        //插入experiment数据
        experiment.setCreateTime(new Date());
        //新增初始化状态为1,正在进行
        experiment.setStatus(1);
        //新增初始化状态为0未开始,正在进行
        experiment.setStatus(0);
        mapper.insert(experiment);

        //插入experiment_base_data数据
@@ -97,32 +112,13 @@
        return new Response().setMsg(1,"新增成功");
    }

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

    public Response<PageInfo<Experiment>> getPage(Integer pageNum, Integer pageSize, ExperimentConditionDTO condition) {
        PageHelper.startPage(pageNum,pageSize);
        List<Experiment> experimentList = mapper.getPage(condition);
        //查询结果的duration是分钟,转换为 x时x分格式
        experimentList.stream().forEach(experiment -> {
            int duration = Integer.parseInt(experiment.getDuration());
            //获取时
            int hour = duration/60;
            //获取分
            int minute = duration%60;
            experiment.setDuration(hour+"小时"+minute+"分");
        });

        PageInfo<Experiment> pageInfo = new PageInfo<>(experimentList);
        return new Response<PageInfo<Experiment>>().set(1,pageInfo);
    }

    /**
     * 检查前置条件
     * @param type
     * @return
     */
    public Response checkPrecondition(String type) {
         AtomicReference<Integer> code = new AtomicReference<>(1);
        AtomicReference<Integer> code = new AtomicReference<>(1);
        //2种方式
        //m1
        QueryWrapper<ExperimentPrecondition> wrapper = Wrappers.query();
@@ -145,4 +141,111 @@
        });
        return new Response().set(code.get(),preconditions);
    }

    /**
     * 检查中置条件-当前功率和当前定子温度,如果符合标准,返回当前值
     */
    public Response checkPreconditionStep1(String type){
        QueryWrapper<ExperimentPrecondition> wrapper = Wrappers.query();
        wrapper.eq("type",type+"_1");
        List<ExperimentPrecondition> preconditions = preconditionMapper.selectList(wrapper);

        //获取到条件数量
        int conditionNum = preconditions.size();
        AtomicReference<Integer> passNum = new AtomicReference(0);
        while (conditionNum!=passNum.get()) {
            //重置为0
            passNum.set(0);
            preconditions.stream().forEach(precondition -> {
                //获取对应的值
                Object preconditionActualValue = commonMapper.getPreconditionStatus(precondition);
                //采用浮点进行数值对比
                Float actualValue = (Float) preconditionActualValue;
                Float defaultValue = Float.parseFloat(precondition.getValue());

                if (defaultValue.equals(actualValue)) {
                    //条件达成,达成数上+1
                    passNum.set(passNum.get()+1);
                    //记录当前值
                    precondition.setActualValue(actualValue.toString());
                }
            });
        }
        return new Response().set(1,preconditions);
    }

    /**
     * 开始试验,更新 试验状态和启动试验时间
     */
    public Response updateStatus(String experimentId){
        Experiment<Object, Object> experiment = new Experiment<>();
        experiment.setId(experimentId);
        experiment.setStatus(1);
        experiment.setStartTime(new Date());
        mapper.updateById(experiment);
        return new Response().set(1,"状态更新成功");
    }

    /**
     * 获取测试点
     */
    public Response<List<ExperimentPoint>> getPoint(String experimentId){
        QueryWrapper<ExperimentPoint> wrapper = Wrappers.query();
        wrapper.eq("experiment_id",experimentId);
        List<ExperimentPoint> experimentPoints = pointMapper.selectList(wrapper);
        return new Response<List<ExperimentPoint>>().set(1,experimentPoints);
    }

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

    /**
     * 启动测试点,并在测试时长过后,返回测试结果
     * @return
     */
    public Response startExperimentPoint(ExperimentPoint point){
        //更新测试时间和测试点状态
        point.setStartTime(new Date());
        point.setStatus(1);
        pointMapper.update(point,null);
        //等待duration时间
        Integer duration = point.getDuration();
        Integer durationSecond = duration*60;
        try {
            sleep(durationSecond);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        pointMapper.updateEndTime(point.getId(),new Date());
        //返回这段时间的测试结果
        Map<String,String> resMap = new HashMap<>();
        int value = (int) (100 + Math.random() * 10);
        resMap.put("平均功率",value+"kW");
        return new Response().set(1,resMap);
    }

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

    public Response<PageInfo<Experiment>> getPage(Integer pageNum, Integer pageSize, ExperimentConditionDTO condition) {
        PageHelper.startPage(pageNum,pageSize);
        List<Experiment> experimentList = mapper.getPage(condition);
        //查询结果的duration是分钟,转换为 x时x分格式
        experimentList.stream().forEach(experiment -> {
            int duration = Integer.parseInt(experiment.getDuration());
            //获取时
            int hour = duration/60;
            //获取分
            int minute = duration%60;
            experiment.setDuration(hour+"小时"+minute+"分");
        });

        PageInfo<Experiment> pageInfo = new PageInfo<>(experimentList);
        return new Response<PageInfo<Experiment>>().set(1,pageInfo);
    }

}

 src/main/java/com/whyc/ws/DeviceWebSocket.java

@@ -32,7 +32,7 @@

    @OnOpen
    public void onOpen(Session session) {
        log.warn("socket会话开启了:{}",session);
        log.warn("DeviceWebSocket会话开启了:{}",session);
        this.session = session;
        //this.deviceId = deviceId;
        if(session!=null) {

 src/main/java/com/whyc/ws/ExperimentSocket.java

New file
@@ -0,0 +1,146 @@
package com.whyc.ws;

import com.whyc.dto.Response;
import com.whyc.pojo.ExperimentPoint;
import com.whyc.service.DeviceService;
import com.whyc.service.ExperimentService;
import io.swagger.annotations.Api;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.Date;
import java.util.List;

import static java.lang.Thread.sleep;

@ServerEndpoint(value = "/experiment/{experimentId}", encoders = WebSocketEncoder.class)
@Component
@Api(tags = "设备ws")
@Slf4j
public class ExperimentSocket {

    private Session session;

    private volatile Thread thread;

    private static ExperimentService service;

    @Autowired
    public void setService(ExperimentService service) {
        this.service = service;
    }

    /**
     * 点击开始试验,开启webSocket,传入试验id,更新试验状态
     *
     * @param session
     * @param experimentId
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("experimentId") String experimentId) {
        log.warn("ExperimentSocket会话开启了:{}", session);
        this.session = session;
        if (session.isOpen()) {
            //session.getBasicRemote().sendObject(service.updateStatus(experimentId));
            service.updateStatus(experimentId);
            sendMessage(experimentId);

        }
    }

    @OnMessage
    public void onMessage(String message) {
        try {
            this.sendMessage(message);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 动态返回步骤和执行信息
     * @param experimentId
     */
    private void sendMessage(String experimentId) {
        String type = experimentId.split("_")[0].toLowerCase();
        try {
            //检查步骤1,属于正式实验前的环境稳定性校验
            session.getBasicRemote().sendObject(service.checkPreconditionStep1(type));

            //正式测试点的数据返回
            //1.返回整体试验点
            Response pointResponse = service.getPoint(experimentId);
            List<ExperimentPoint> experimentPoints = (List<ExperimentPoint>) pointResponse.getData();
            experimentPoints.stream().forEach(experimentPoint -> {
                //启动第一个测试点,返回整体状态
                experimentPoint.setStatus(1);
                experimentPoint.setStartTime(new Date());
                service.updatePointStatus(experimentPoint);
                try {
                    session.getBasicRemote().sendObject(experimentPoints);
                } catch (IOException | EncodeException e) {
                    e.printStackTrace();
                }
                try {
                    //等待一个测试时间
                    sleep(experimentPoint.getDuration());
                    //更新第一个测试点的情况,获取整个时间的情况

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            });

        } catch (IOException | EncodeException e) {
            e.printStackTrace();
        }
        if(session!=null) {
            thread = new Thread("Thread_device") {
                public void run() {
                    while (!thread.isInterrupted()) {

                        if (session.isOpen()) {
                            //session.getBasicRemote().sendObject(service.getStatus());
                            try {
                                session.getBasicRemote().sendObject("yeah!");
                            } catch (IOException | EncodeException e) {
                                e.printStackTrace();
                            }
                        }
                        try {
                            sleep(1000);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

                    }
                }
            };
            thread.start();
        }
    }

    @OnClose
    public void onClose() {
        if (thread != null && thread.isAlive()) {
            thread.interrupt();
        }
        log.warn("webSocket会话关闭了:{}", session);

    }

    @OnError
    public void onError(Throwable error) {
        error.printStackTrace();
        if (thread != null && thread.isAlive()) {
            thread.interrupt();
        }
    }

}