a8000/src/main/java/com/iflytop/a800/controller/TestController.java

package com.iflytop.a800.controller;
import com.iflytop.a800.TaskManager;
import com.iflytop.a800.model.*;
import com.iflytop.a800.resource.TestTube;
import com.iflytop.a800.task.TubeRackTask;
import com.iflytop.a800.task.TubeTestTask;
import com.iflytop.uf.UfActiveRecord;
import com.iflytop.uf.controller.UfApiControllerBase;
import com.iflytop.uf.controller.UfApiResponse;
import com.iflytop.uf.model.UfMdbDictItem;
import com.iflytop.uf.util.UfJsonHelper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
@Controller
public class TestController extends UfApiControllerBase {
    @PostMapping("/api/test/emergency-task-get")
    @ResponseBody
    public UfApiResponse emergencyTaskGet() {
        var task = UfActiveRecord.findOne(MdbEmergencyTestTask.class, Map.of("isFinished", "no"));
        return this.success(task);
    }

    @PostMapping("/api/test/emergency-task-append")
    @ResponseBody
    public UfApiResponse emergencyTaskAppend(@RequestBody Map<String, Object> params) {
        List<String> projectIds = (List<String>)params.get("projectIds");

        var taskModel = new MdbEmergencyTestTask();
        taskModel.attenuation = (String)params.get("attenuation");
        taskModel.barCode = (String)params.get("barCode");
        taskModel.projectDetectType = (String)params.get("projectDetectType");
        taskModel.projectIds = UfJsonHelper.objectToJson(projectIds);
        taskModel.sampleTypeDetectType = (String)params.get("sampleTypeDetectType");
        taskModel.sampleType = (String)params.get("sampleType");
        taskModel.sampleUid = (String)params.get("sampleUid");
        taskModel.status = UfMdbDictItem.getValue("TEST_TASK_STATUS", "NEW");
        taskModel.isFinished = "no";
        taskModel.createdAt = System.currentTimeMillis();
        taskModel.save();

        var tube = new TestTube();
        tube.isExisted = true;
        tube.type = "EmergencyTube";
        tube.barCode = taskModel.barCode;
        tube.index = 0;

        var taskMan = TaskManager.getInstance();
        for ( var projectId : projectIds ) {
            var project = UfActiveRecord.findOne(MdbProject.class, Map.of("id", projectId));
            var testTask = new TubeTestTask();
            testTask.tube = tube;
            testTask.project = project;
            taskMan.append(testTask);
        }

        return this.success();
    }

    @PostMapping("/api/test/test-tube-rack-list")
    @ResponseBody
    public UfApiResponse testTubeRackList() {
        var tasks = UfActiveRecord.find(MdbTubeRackTestTask.class);

        var list = new ArrayList<Map<String, Object>>();
        for ( var task : tasks ) {
            var item = task.toMap();
            var tubeList = new ArrayList<Map<String, Object>>();
            for ( var tube : task.getTubes() ) {
                var tubeItem = tube.toMap();
                tubeItem.put("projects", tube.getProjects());
                tubeItem.put("projectIds", tube.getProjectIdList());
                tubeList.add(tubeItem);
            }
            item.put("tubes", tubeList);
            list.add(item);
        }

        return this.success(list);
    }

    @PostMapping("/api/test/test-tube-rack-save")
    @ResponseBody
    public UfApiResponse tubeRackTaskSave(@RequestBody Map<String, Object> params) {
        var task = new MdbTubeRackTestTask();
        task.id = (String)params.get("id");
        task.isNewRecord = null == params.get("id");
        task.setAttributes(params);
        task.status = UfMdbDictItem.getValue("TUBE_RACK_TASK_STATUS", "CONFIGURING");
        task.save();

        var oldTubes = UfActiveRecord.find(MdbTubeRackTestTaskTube.class, Map.of("rackId", task.id));
        for ( var tube : oldTubes ) {
            tube.delete();
        }

        var tubes = (List<Map<String, Object>>)params.get("tubes");
        for ( var tube : tubes ) {
            var projectIds = (List<String>)tube.get("projectIds");
            tube.put("projectIds", UfJsonHelper.objectToJson(projectIds));
            var tubeModel = new MdbTubeRackTestTaskTube();
            tubeModel.rackId = task.id;
            tubeModel.status = UfMdbDictItem.getValue("TUBE_STATUS", "NEW");
            tubeModel.setAttributes(tube);
            tubeModel.save();
        }

        return this.success(task);
    }

    @PostMapping("/api/test/test-tube-rack-delete")
    @ResponseBody
    public UfApiResponse tubeRackTaskDelete(@RequestBody Map<String, Object> params) {
        String id = (String)params.get("id");
        var task = UfActiveRecord.findOne(MdbTubeRackTestTask.class, id);
        task.delete();
        return this.success();
    }

    @PostMapping("/api/test/test-tube-rack-lock")
    @ResponseBody
    public UfApiResponse tubeRackTaskLock(@RequestBody Map<String, Object> params) {
        String id = (String)params.get("id");
        var task = UfActiveRecord.findOne(MdbTubeRackTestTask.class, id);
        task.status = UfMdbDictItem.getValue("TUBE_RACK_TASK_STATUS", "WAITING");
        task.save();

        // 如果没有正在执行的试管架任务则提交任务
        var taskMan = TaskManager.getInstance();
        var testTask = new TubeRackTask(task);
        taskMan.append(testTask);
        return this.success();
    }

    @PostMapping("/api/test/test-tube-rack-unlock")
    @ResponseBody
    public UfApiResponse tubeRackTaskUnlock(@RequestBody Map<String, Object> params) {
        String id = (String)params.get("id");
        var task = UfActiveRecord.findOne(MdbTubeRackTestTask.class, id);
        task.status = UfMdbDictItem.getValue("TUBE_RACK_TASK_STATUS", "CONFIGURING");
        task.save();
        return this.success();
    }

    @PostMapping("/api/test/test-tube-rack-status-get")
    @ResponseBody
    public UfApiResponse tubeRackStatusGet() {
        var statusProcessing = UfMdbDictItem.getValue("TUBE_RACK_TASK_STATUS", "PROCESSING");
        var rack = UfActiveRecord.findOne(MdbTubeRackTestTask.class, Map.of("status", statusProcessing));
        if ( null == rack ) {
            return this.success(null);
        }

        var tubeList = new ArrayList<Map<String, Object>>();
        var tubes = rack.getTubes();
        for ( var tube : tubes ) {
            var tubeItem = tube.toMap();
            tubeItem.put("projects", tube.getProjects());
            tubeList.add(tubeItem);
        }

        var result = rack.toMap();
        result.put("tubes", tubeList);
        return this.success(result);
    }

    @PostMapping("/api/test/active-batch-list")
    @ResponseBody
    public UfApiResponse activeBatchList() {
        var tests = UfActiveRecord.find(MdbTest.class);
        var list = new ArrayList<Map<String, Object>>();
        for ( var test : tests ) {
            var item = test.toMap();
            list.add(item);
        }
        return this.success(list);
    }
}