Merge remote-tracking branch 'origin/master'

zss

2024-07-18 4d7d9ee75f529c9e1d66f98608edf18221f76acd

Merge remote-tracking branch 'origin/master'

 cnas-server/src/main/java/com/yuanchu/mom/controller/DeviceController.java

@@ -1,12 +1,14 @@
package com.yuanchu.mom.controller;


import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.yuanchu.mom.annotation.ValueAuth;
import com.yuanchu.mom.annotation.ValueClassify;
import com.yuanchu.mom.dto.DataConfigDto;
import com.yuanchu.mom.dto.DeviceDto;
import com.yuanchu.mom.exception.ErrorException;
import com.yuanchu.mom.pojo.DataConfig;
import com.yuanchu.mom.pojo.Device;
import com.yuanchu.mom.service.DataConfigService;
@@ -15,7 +17,6 @@
import com.yuanchu.mom.utils.JackSonUtil;
import com.yuanchu.mom.vo.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiModelProperty;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
@@ -27,7 +28,6 @@
import java.io.File;
import java.time.LocalDateTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@@ -164,11 +164,37 @@
//    }

    @ValueAuth
    @ApiModelProperty("/数采")
    @GetMapping("/text")
    public Result<?> text(HttpServletRequest request) {
        List<DataConfig> list = new ArrayList<>();
        return Result.success(DataAcquisition.dataAcquisitionEntrance(request,list));
    @ValueClassify("设备")
    @ApiOperation("/数采-数据采集")
    @GetMapping("/dataCollection")
    public Result<?> text(HttpServletRequest request, @RequestParam("managementNumber") String managementNumber,
                          @RequestParam("entrustCode") String entrustCode,
                          @RequestParam("sampleCode") String sampleCode) {
        Device device = deviceService.getOne(Wrappers.<Device>lambdaQuery()
                .eq(Device::getManagementNumber, managementNumber));
        if (ObjectUtils.isEmpty(device.getFileType()) || ObjectUtils.isEmpty(device.getCollectUrl())) {
            throw new ErrorException("未给该：" + device.getDeviceName() + "设备配置采集路径或文件后缀！");
        }
        List<DataConfig> list = dataConfigService.list(Wrappers.<DataConfig>lambdaQuery()
                .eq(DataConfig::getDeviceId, device.getId())
                .orderBy(false, false, DataConfig::getId));
        return DataAcquisition.dataAcquisitionEntrance(request,list, device, entrustCode, sampleCode);
    }

    @ValueAuth
    @ApiOperation(value = "判断该设备是否可以数采")
    @GetMapping("/determineWhetherToCollectData")
    public Result<?> determineWhetherToCollectData(@RequestParam("managementNumber") String managementNumber) {
        Device device = deviceService.getOne(Wrappers.<Device>lambdaQuery()
                .eq(Device::getManagementNumber, managementNumber));
        if (ObjectUtils.isEmpty(device)) {
            return Result.fail("设备编号错误！");
        }
        if (ObjectUtils.isEmpty(device.getFileType()) || ObjectUtils.isEmpty(device.getCollectUrl())) {
            return Result.success(false);
        } else {
            return Result.success(true);
        }
    }

    @ValueClassify("设备")

 cnas-server/src/main/java/com/yuanchu/mom/pojo/Device.java

@@ -127,4 +127,8 @@

    @ApiModelProperty("存储地址")
    private String storageUrl;

    @ApiModelProperty("是否为数采设备")
    @TableField(exist = false)
    private Boolean isItADataAcquisitionDevice;
}

 cnas-server/src/main/java/com/yuanchu/mom/service/impl/DeviceServiceImpl.java

@@ -8,7 +8,6 @@
import com.yuanchu.mom.common.GetLook;
import com.yuanchu.mom.common.PrintChina;
import com.yuanchu.mom.dto.DeviceDto;
import com.yuanchu.mom.dto.DeviceDto1;
import com.yuanchu.mom.mapper.DeviceMapper;
import com.yuanchu.mom.mapper.StructureItemParameterMapper;
import com.yuanchu.mom.pojo.Device;
@@ -107,6 +106,11 @@
            String[] ids = device.getInsProductIds().split(",");
            for (String i : ids) {
                if (i.equals(id + "")) {
                    if (ObjectUtils.isEmpty(device.getFileType()) || ObjectUtils.isEmpty(device.getCollectUrl())) {
                        device.setIsItADataAcquisitionDevice(false);
                    } else {
                        device.setIsItADataAcquisitionDevice(true);
                    }
                    devices2.add(device);
                    break;
                }

 cnas-server/src/main/java/com/yuanchu/mom/utils/DataAcquisition.java

@@ -1,32 +1,396 @@
package com.yuanchu.mom.utils;

import cn.hutool.core.io.IORuntimeException;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.toolkit.ObjectUtils;
import com.yuanchu.mom.exception.ErrorException;
import com.yuanchu.mom.pojo.DataConfig;
import com.yuanchu.mom.pojo.Device;
import com.yuanchu.mom.vo.Result;

import javax.servlet.http.HttpServletRequest;
import java.util.List;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

public class DataAcquisition {

    private static final String HTTP = "http://";

    private static final String GETFILE = "/lims/getFile";
    private static final String GETFILE = ":9527/lims/getFile"; // 获取文件接口

    private static final String MOVEFILE = "/lims/moveFile";
    private static final String MOVEFILE = ":9527/lims/moveFile"; // 文件移动地址

    public static Result<?> dataAcquisitionEntrance(HttpServletRequest request, List<DataConfig> dataConfig) {
    private static final String splitIdentifier = "@-@"; // 自定义唯一标识分割符

    /**
     * 数采入口
     * @param request
     * @param dataConfig
     * @param device
     * @return
     */
    public static Result<?> dataAcquisitionEntrance(HttpServletRequest request, List<DataConfig> dataConfig, Device device, String entrustCode, String sampleCode) {
        String ipAddress = request.getRemoteAddr();
        // 防止回环地址变为IPv6
        String ip = ipAddress.equals("0:0:0:0:0:0:0:1") ? "127.0.0.1" : ipAddress;
//        String http = HTTP + ip + GETFILE + "?filePath=" + dataConfig.get(0).getCollectUrl() + "&fileExtension=" + dataConfig.get(0).getFileType();
//        String result = HttpUtil.get(http);
//        JSONObject jsonObject =  JSON.parseObject(result);
//        if (Objects.equals(jsonObject.get("code"), 1)) {
//            throw new ErrorException(jsonObject.get("message").toString());
//        } else {
//            Object data = jsonObject.get("data");
//
//        }
        return null;
        String http = HTTP + ip + GETFILE + "?filePath=" + device.getCollectUrl() + "&fileExtension=" + device.getFileType();
        String result = null;
        try {
            result = HttpUtil.get(http);
        } catch (IORuntimeException e) {
            throw new ErrorException("所在电脑未安装或未启动：LIMS文件采集器！");
        }
        JSONObject jsonObject =  JSON.parseObject(result);
        if (Objects.equals(jsonObject.get("code"), 1)) {
            if (ObjectUtils.isEmpty(jsonObject.get("msg"))) {
                throw new ErrorException("未查询到数据，可能文件路径配置错误！");
            } else {
                System.out.println(jsonObject);
                throw new ErrorException("未知错误，请联系管理员！");
            }
        } else {
            String data = jsonObject.get("data").toString();
            // 考虑到一个检测项可能会存在多个数采配置，所以需要进行分组
            Map<String, List<DataConfig>> userMap = dataConfig.stream().collect(Collectors.groupingBy(DataConfig::getInsProductItem));
            Map<String, String> map;
            switch (device.getFileType()) {
                case ".docx":
                    map = analysisString(data, userMap);
                    break;
                case ".xlsx":
                    map = analysisList(data, userMap);
                    break;
                case ".txt":
                    map = analysisTxt(data, userMap);
                    break;
                case ".csv":
                    map = analysisList(data, userMap);
                    break;
                case ".mdb":
                    map = analysisMdb(data, userMap, entrustCode, sampleCode);
                    break;
                case ".db":
                    map = analysisDb(data, userMap);
                    break;
                case ".png":
                    map = readPngString(data, userMap);
                    break;
                default:
                    map = null;
                    break;
            }
            // 如果存在存储地址，则移动地址
            if (ObjectUtils.isNotEmpty(device.getStorageUrl())) {
                String s = HTTP + ip + MOVEFILE + "?startFilePath=" + device.getCollectUrl() + "&endFilePath=" + device.getStorageUrl();
                String storageUrlResult = HttpUtil.get(s);
                JSONObject storageUrlResultJson =  JSON.parseObject(storageUrlResult);
                if (Objects.equals(storageUrlResultJson.get("code"), 1)) {
                    if (ObjectUtils.isEmpty(storageUrlResultJson.get("msg"))) {
                        throw new ErrorException("存储地址错误，可能文件路径配置错误！");
                    } else {
                        throw new ErrorException("未知错误，请联系管理员！");
                    }
                }
            }
            return Result.success(map);
        }
    }

    private static Map<String, String> analysisDb(String data, Map<String, List<DataConfig>> dataConfig) {
        JSONObject jsonObject = JSON.parseObject(data);
        JSONArray dataList = JSONArray.parseArray(jsonObject.get("data").toString());
        JSONArray columnList = JSONArray.parseArray(jsonObject.get("column").toString());
        Map<String, String> map = new HashMap<>();
        dataConfig.forEach((k, v) -> {
            List<Object> list = new ArrayList<>();
            for (int config = 0; config < v.size(); config++) {
                String referx = v.get(config).getReferx();
                if(ObjectUtils.isEmpty(v.get(config).getX()) && ObjectUtils.isEmpty(v.get(config).getY())) {
                    throw new ErrorException("未给" + k + "进行数采配置x，y！");
                }
                int x = Integer.parseInt(v.get(config).getX());
                int y = Integer.parseInt(v.get(config).getY());
                String key = "";
                for (int i = 0; i < columnList.size(); i++) {
                    if (columnList.get(i).equals(referx)) {
                        key = columnList.get(i + x).toString();
                    }
                }
                JSONObject jsonObject1 = JSON.parseObject(dataList.get(y).toString());
                Object o = jsonObject1.get(key);
                if (ObjectUtils.isNotEmpty(o)) {
                    list.add(o);
                }
            }
            // 进行公式计算
            String resultValue = calculationFormula(list, v.get(0));
            map.put(k, resultValue);
        });
        return map;
    }

    private static Map<String, String> analysisMdb(String data, Map<String, List<DataConfig>> dataConfig, String entrustCode, String sampleCode) {
        JSONObject jsonObject = JSON.parseObject(data);
        JSONArray dataList = JSONArray.parseArray(jsonObject.get("data").toString());
        JSONArray columnList = JSONArray.parseArray(jsonObject.get("column").toString());
        Map<String, String> map = new HashMap<>();
        dataConfig.forEach((k, v) -> {
            List<Object> list = new ArrayList<>();
            for (int config = 0; config < v.size(); config++) {
                String referx = v.get(config).getReferx();
                int x = Integer.parseInt(v.get(config).getX());
                String key = "";
                for (int i = 0; i < columnList.size(); i++) {
                    if (columnList.get(i).equals(referx)) {
                        key = columnList.get(i + x).toString();
                    }
                }
                for (int i = 0; i < dataList.size(); i++) {
                    JSONObject jsonObject1 = JSON.parseObject(dataList.get(i).toString());
                    if (entrustCode.equals(jsonObject1.get("OrderNumber")) && sampleCode.equals(jsonObject1.get("SampleNumber"))) {
                        Object o = jsonObject1.get(key);
                        if (ObjectUtils.isNotEmpty(o)) {
                            list.add(o);
                        }
                    }
                }
            }
            // 进行公式计算
            String resultValue = calculationFormula(list, v.get(0));
            map.put(k, resultValue);
        });
        return map;
    }

    private static Pattern SPATTERN = Pattern.compile("([-+])?\\d+(\\.\\d+)?");
    /**
     * 解析String数据
     * @param data 采集到的文件字符串
     * @param dataConfig 用户配置好的x,y轴定位数据与参照物
     * @return
     */
    private static Map<String, String> readPngString(String data, Map<String, List<DataConfig>> dataConfig) {
        Map<String, String> map = new HashMap<>();
        dataConfig.forEach((k, v) -> {
            List<Object> list = new ArrayList<>();
            for (int config = 0; config < v.size(); config++) {
                String referx = v.get(config).getReferx();
                String xResult = null;
                // 通过\n将字符串分割为行
                String[] aColumnY = data.split("\n");
                List<String> list1 = new ArrayList<>();
                // 该循环得出用户配置的y轴
                for (int i = 0; i < aColumnY.length; i++) {
                    String addDataWithSpaces = referx.replaceAll("", " ");
                    int x = Integer.parseInt(v.get(config).getX());
                    if (aColumnY[i].contains(addDataWithSpaces)) {
                        Matcher matcher = SPATTERN.matcher(aColumnY[i]);
                        while (matcher.find()) {
                            String group = matcher.group();
                            list1.add(group);
                        }
                    }
                    if (ObjectUtils.isNotEmpty(list1)) {
                        xResult = list1.get(x);
                    }
                }
                if (ObjectUtils.isNotEmpty(xResult)) {
                    list.add(xResult);
                }
            }
            // 进行公式计算
            String resultValue = calculationFormula(list, v.get(0));
            map.put(k, resultValue);
        });
        return map;
    }

    /**
     * 从文件中提取出来的文字，如果有公式，进行公式计算，否则取列表第一个值
     * @param list 提取出的数字
     * @param dataConfig 存储公式的对象
     * @return
     */
    private static String calculationFormula(List<Object> list, DataConfig dataConfig) {
        // 如果不为空，进行公式计算
        if (ObjectUtils.isNotEmpty(dataConfig.getFormula())) {

            return null;
        // 否则：没有公式代表不需要计算，直接提取List里面的数据
        } else {
            // 这里只会取列表第一个数据
            if (list.size() > 0) {
                return list.get(0).toString();
            }
            return null;
        }
    }

    /**
     * 解析String数据
     * @param data 采集到的文件字符串
     * @param dataConfig 用户配置好的x,y轴定位数据与参照物
     * @return
     */
    private static Map<String, String> analysisTxt(String data, Map<String, List<DataConfig>> dataConfig) {
        Map<String, String> map = new HashMap<>();
        dataConfig.forEach((k, v) -> {
            List<Object> list = new ArrayList<>();
            for (int config = 0; config < v.size(); config++) {
                String referx = v.get(config).getReferx();
                String refery = v.get(config).getRefery();
                String xResult = null;
                String yResult = null;
                // 通过\n将字符串分割为行
                String[] aColumnY = data.split("\n");
                // 该循环得出用户配置的y轴
                for (int i = 0; i < aColumnY.length; i++) {
                    // 得出用户配置的x轴
                    String[] aLineX = aColumnY[i].split(",");
                    for (int j = 0; j < aLineX.length; j++) {
                        if (ObjectUtils.isNotEmpty(referx) && aLineX[j].contains(referx)) {
                            int x = Integer.parseInt(v.get(config).getX());
                            try {
                                xResult = aLineX[j + x];
                            } catch (Exception e) {
                                throw new ErrorException("数采配置X轴超出！");
                            }
                        }
                        if (ObjectUtils.isNotEmpty(refery) && aLineX[j].contains(refery)) {
                            int y = Integer.parseInt(v.get(config).getY());
                            try {
                                String[] split = aColumnY[i + y].split(",");
                                yResult = split[split.length - 1];
                            } catch (Exception e) {
                                throw new ErrorException("数采配置Y轴超出！");
                            }
                        }
                    }
                }
                if (ObjectUtils.isEmpty(xResult) && ObjectUtils.isEmpty(yResult)) {
                    throw new ErrorException("参照物为：" + referx + "与" + refery + "未取到值！请检查数采配置！");
                }
                list.add(yResult);
                list.add(xResult);
            }
            // 进行公式计算
            String resultValue = calculationFormula(list, v.get(0));
            map.put(k, resultValue);
        });
        return map;
    }

    /**
     * 解析String数据
     * @param data 采集到的文件字符串
     * @param dataConfig 用户配置好的x,y轴定位数据与参照物
     * @return
     */
    private static Map<String, String> analysisString(String data, Map<String, List<DataConfig>> dataConfig) {
        String processingDataAfterSpaces = data.replaceAll("  +", splitIdentifier).replaceAll("\r", "");
        Map<String, String> map = new HashMap<>();
        dataConfig.forEach((k, v) -> {
            List<Object> list = new ArrayList<>();
            for (int config = 0; config < v.size(); config++) {
                String referx = v.get(config).getReferx();
                String xResult = null;
                // 通过\n将字符串分割为行
                String[] aColumnY = processingDataAfterSpaces.split("\n");
                // 该循环得出用户配置的y轴
                for (int i = 0; i < aColumnY.length; i++) {
                    // 得出用户配置的x轴
                    String[] aLineX = aColumnY[i].split(splitIdentifier);
                    for (int j = 0; j < aLineX.length; j++) {
                        if (ObjectUtils.isNotEmpty(referx) && aLineX[j].replaceAll(" ", "").contains(referx.replaceAll(" ", ""))) {
                            int x = Integer.parseInt(v.get(config).getX());
                            try {
                                xResult = aLineX[j + x];
                            } catch (Exception e) {
                                throw new ErrorException("数采配置X轴超出！");
                            }
                        }
                    }
                }
                if (ObjectUtils.isEmpty(xResult)) {
                    throw new ErrorException("参照物为：" + referx + "未取到值！请检查数采配置！");
                }
                // 结果包含特殊字符，需要剔除掉
                if(xResult.contains("=")) {
                    String[] split = xResult.split("=");
                    list.add(split[split.length - 1]);
                } else if (xResult.contains(":")) {
                    String[] split = xResult.split(":");
                    list.add(split[split.length - 1].replaceAll("%", ""));
                } else {
                    list.add(xResult);
                }
            }
            // 进行公式计算
            String resultValue = calculationFormula(list, v.get(0));
            map.put(k, resultValue);
        });
        return map;
    }

    /**
     * 解析String数据
     * @param data 采集到的文件字符串
     * @param dataConfig 用户配置好的x,y轴定位数据与参照物
     * @return
     */
    public static Map<String, String> analysisList(String data, Map<String, List<DataConfig>> dataConfig) {
        Map<String, String> map = new HashMap<>();
        dataConfig.forEach((k, v) -> {
            List<Object> list = new ArrayList<>();
            for (int config = 0; config < v.size(); config++) {
                String referx = v.get(config).getReferx();
                String refery = v.get(config).getRefery();
                String xResult = null;
                String yResult = null;
                // 通过\n将字符串分割为行
                String[] aColumnY = data.split("\n");
                // 该循环得出用户配置的y轴
                for (int i = 0; i < aColumnY.length; i++) {
                    // 得出用户配置的x轴
                    String[] aLineX = aColumnY[i].split(splitIdentifier);
                    for (int j = 0; j < aLineX.length; j++) {
                        if (ObjectUtils.isNotEmpty(referx) && referx.equals(aLineX[j])) {
                            int x = Integer.parseInt(v.get(config).getX());
                            try {
                                xResult = aLineX[j + x];
                            } catch (Exception e) {
                                throw new ErrorException("数采配置X轴超出！");
                            }
                        }
                        if (ObjectUtils.isNotEmpty(refery) && refery.equals(aLineX[j])) {
                            int y = Integer.parseInt(v.get(config).getY());
                            String aColumnData = aColumnY[i + y]; // 获取到第Y行的数据
                            try {
                                yResult = aColumnData.split(splitIdentifier)[j];
                            } catch (Exception e) {
                                throw new ErrorException("数采配置Y轴超出！");
                            }
                        }
                    }
                }
                if (ObjectUtils.isEmpty(xResult) || ObjectUtils.isEmpty(yResult)) {
                    throw new ErrorException("X轴或Y轴未取到值！请检查数采配置！");
                }
                if(xResult.equals(yResult)) {
                    list.add(xResult);
                } else {
                    throw new ErrorException("X轴与Y轴取得的数据不相同！请检查数采配置！");
                }
            }
            // 进行公式计算
            String resultValue = calculationFormula(list, v.get(0));
            map.put(k, resultValue);
        });
        return map;
    }
}