实时采集井相关、预警参数动态调整

yujing-common/src/main/java/com/cn/tianji/entity/YjDrillingDataSupplementationLog.java

@@ -0,0 +1,53 @@
+package com.cn.tianji.entity;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * 钻井数据补录日志表;
+ *
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-2
+ */
+@TableName("yj_drilling_data_supplementation_log")
+@Data
+public class YjDrillingDataSupplementationLog implements Serializable {
+
+    /**
+     * 主键
+     */
+    @TableId
+    private String id;
+    /**
+     * 井号
+     */
+    private String jh;
+    /**
+     * 井表名
+     */
+    private String jhTableName;
+    /**
+     * 开始时间
+     */
+    private Date startTime;
+    /**
+     * 结束时间
+     */
+    private Date endTime;
+    /**
+     * 补录数量
+     */
+    private Integer dataNum;
+    /**
+     * 状态;0:待开始 1:补录中 2:已完成
+     */
+    private String status;
+    /**
+     * 创建时间
+     */
+    private Date createTime;
+}

yujing-common/src/main/java/com/cn/tianji/entity/YjPumpingWarnValue.java

@@ -0,0 +1,58 @@
+package com.cn.tianji.entity;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 泵压预警阈值;
+ *
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@TableName("yj_pumping_warn_value")
+@Data
+public class YjPumpingWarnValue implements Serializable, Cloneable {
+
+    /**
+     * 主键
+     */
+    @TableId
+    private String id;
+    /**
+     * 井号
+     */
+    private String jh;
+    /**
+     * 泵压监测最小值
+     */
+    private BigDecimal pumpingMin;
+    /**
+     * 泵压监测最大值
+     */
+    private BigDecimal pumpingMax;
+    /**
+     * 总泵冲监测阈值
+     */
+    private BigDecimal pumpingWarnValue;
+    /**
+     * 泵压监测阈值 0代表无限大
+     */
+    private BigDecimal sppWarnValue;
+    /**
+     * 钻头监测阈值
+     */
+    private BigDecimal bitdepth;
+    /**
+     * 排序码
+     */
+    private Integer sortCode;
+    /**
+     * 创建时间
+     */
+    private Date createTime;
+}

yujing-common/src/main/java/com/cn/tianji/entity/YjRealTimeLog.java

@@ -0,0 +1,44 @@
+package com.cn.tianji.entity;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+import oracle.sql.DATE;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+import java.util.Date;
+
+/**
+ * 预警实时日志表;
+ *
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-2
+ */
+@TableName("yj_real_time_log")
+@Data
+public class YjRealTimeLog implements Serializable {
+
+    /**
+     * 主键
+     */
+    @TableId
+    private String id;
+    /**
+     * 井号
+     */
+    private String jh;
+    /**
+     * 状态
+     */
+    private String status;
+    /**
+     * 最近采集时间
+     */
+    private Date realTime;
+    /**
+     * 创建时间
+     */
+    private Date createTime;
+
+}

yujing-common/src/main/java/com/cn/tianji/entity/YjTorqueWarnValue.java

@@ -0,0 +1,58 @@
+package com.cn.tianji.entity;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 扭矩预警阈值;
+ *
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@TableName("yj_torque_warn_value")
+@Data
+public class YjTorqueWarnValue implements Serializable, Cloneable {
+
+    /**
+     * 主键
+     */
+    @TableId
+    private String id;
+    /**
+     * 井号
+     */
+    private String jh;
+    /**
+     * 扭矩监测最小值
+     */
+    private BigDecimal torqueMin;
+    /**
+     * 扭矩监测最大值
+     */
+    private BigDecimal torqueMax;
+    /**
+     * 均值预警值
+     */
+    private BigDecimal varianceWarnValue;
+    /**
+     * 波动值预警值
+     */
+    private BigDecimal fluctuateWarn;
+    /**
+     * 钻头监测阈值
+     */
+    private BigDecimal bitdepth;
+    /**
+     * 排序码
+     */
+    private Integer sortCode;
+    /**
+     * 创建时间
+     */
+    private Date createTime;
+}

yujing-common/src/main/java/com/cn/tianji/entity/YjTotalPoolWarnValue.java

@@ -0,0 +1,50 @@
+package com.cn.tianji.entity;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 总池体积预警阈值;
+ *
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@TableName("yj_total_pool_warn_value")
+@Data
+public class YjTotalPoolWarnValue implements Serializable {
+
+    /**
+     * 主键
+     */
+    @TableId
+    private String id;
+    /**
+     * 井号
+     */
+    private String jh;
+    /**
+     * 均值阈值
+     */
+    private BigDecimal pittotalWarn;
+    /**
+     * 速率阈值
+     */
+    private BigDecimal ranteWarn;
+    /**
+     * 钻头监测阈值
+     */
+    private BigDecimal bitdepth;
+    /**
+     * 预警类别
+     */
+    private String warnType;
+    /**
+     * 创建时间
+     */
+    private Date createTime;
+}

yujing-common/src/main/java/com/cn/tianji/entity/YjWohWarnValue.java

@@ -0,0 +1,54 @@
+package com.cn.tianji.entity;
+
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import lombok.Data;
+
+import java.io.Serializable;
+import java.math.BigDecimal;
+import java.util.Date;
+
+/**
+ * 钩载预警阈值管理;
+ *
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@TableName("yj_woh_warn_value")
+@Data
+public class YjWohWarnValue implements Serializable, Cloneable {
+
+    /**
+     * 主键
+     */
+    @TableId
+    private String id;
+    /**
+     * 井号
+     */
+    private String jh;
+    /**
+     * 钻杆重量
+     */
+    private BigDecimal rodWeight;
+    /**
+     * 持续起下钻钩载阈值
+     */
+    private BigDecimal sustainWoh;
+    /**
+     * 第一种活动钻具阈值
+     */
+    private BigDecimal activityOne;
+    /**
+     * 第二种活动钻具阈值
+     */
+    private BigDecimal activityTwo;
+    /**
+     * 钻头监测阈值
+     */
+    private BigDecimal bitdepth;
+    /**
+     * 创建时间
+     */
+    private Date createTime;
+}

yujing-common/src/main/java/com/cn/tianji/mapper/YjDrillingDataSupplementationLogMapper.java

@@ -0,0 +1,14 @@
+package com.cn.tianji.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.cn.tianji.entity.YjDrillingDataSupplementationLog;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 钻井数据补录日志表;(yj_drilling_data_supplementation_log)表数据库访问层
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-2
+ */
+@Mapper
+public interface YjDrillingDataSupplementationLogMapper  extends BaseMapper<YjDrillingDataSupplementationLog> {
+}

yujing-common/src/main/java/com/cn/tianji/mapper/YjPumpingWarnValueMapper.java

@@ -0,0 +1,15 @@
+package com.cn.tianji.mapper;
+
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.cn.tianji.entity.YjPumpingWarnValue;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 泵压预警阈值;(yj_pumping_warn_value)表数据库访问层
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@Mapper
+public interface YjPumpingWarnValueMapper extends BaseMapper<YjPumpingWarnValue> {
+}

yujing-common/src/main/java/com/cn/tianji/mapper/YjRealTimeLogMapper.java

@@ -0,0 +1,17 @@
+package com.cn.tianji.mapper;
+
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.cn.tianji.entity.YjRealTimeLog;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 预警实时日志表;(yj_real_time_log)表数据库访问层
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-2
+ */
+@Mapper
+public interface YjRealTimeLogMapper  extends BaseMapper<YjRealTimeLog> {
+
+    void truncateTable();
+}

yujing-common/src/main/java/com/cn/tianji/mapper/YjTorqueWarnValueMapper.java

@@ -0,0 +1,14 @@
+package com.cn.tianji.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.cn.tianji.entity.YjTorqueWarnValue;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 扭矩预警阈值;(yj_torque_warn_value)表数据库访问层
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@Mapper
+public interface YjTorqueWarnValueMapper  extends BaseMapper<YjTorqueWarnValue> {
+}

yujing-common/src/main/java/com/cn/tianji/mapper/YjTotalPoolWarnValueMapper.java

@@ -0,0 +1,14 @@
+package com.cn.tianji.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.cn.tianji.entity.YjTotalPoolWarnValue;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 总池体积预警阈值;(yj_total_pool_warn_value)表数据库访问层
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@Mapper
+public interface YjTotalPoolWarnValueMapper extends BaseMapper<YjTotalPoolWarnValue> {
+}

yujing-common/src/main/java/com/cn/tianji/mapper/YjWohWarnValueMapper.java

@@ -0,0 +1,15 @@
+package com.cn.tianji.mapper;
+
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.cn.tianji.entity.YjWohWarnValue;
+import org.apache.ibatis.annotations.Mapper;
+
+/**
+ * 钩载预警阈值管理;(yj_woh_warn_value)表数据库访问层
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@Mapper
+public interface YjWohWarnValueMapper  extends BaseMapper<YjWohWarnValue> {
+}

yujing-common/src/main/java/com/cn/tianji/service/YjDrillingDataSupplementationLogService.java

@@ -0,0 +1,7 @@
+package com.cn.tianji.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.cn.tianji.entity.YjDrillingDataSupplementationLog;
+
+public interface YjDrillingDataSupplementationLogService extends IService<YjDrillingDataSupplementationLog> {
+}

yujing-common/src/main/java/com/cn/tianji/service/YjPumpingWarnValueService.java

@@ -0,0 +1,10 @@
+package com.cn.tianji.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.cn.tianji.entity.YjPumpingWarnValue;
+
+import java.util.List;
+
+public interface YjPumpingWarnValueService  extends IService<YjPumpingWarnValue> {
+    List<YjPumpingWarnValue> getListByJh(String jh);
+}

yujing-common/src/main/java/com/cn/tianji/service/YjRealTimeLogService.java

@@ -0,0 +1,12 @@
+package com.cn.tianji.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.cn.tianji.entity.YjRealTimeLog;
+
+import java.util.List;
+
+public interface YjRealTimeLogService extends IService<YjRealTimeLog> {
+    void saveRealTimeLog(List<String> jhLit);
+
+    void updateBatchJhStatus();
+}

yujing-common/src/main/java/com/cn/tianji/service/YjTorqueWarnValueService.java

@@ -0,0 +1,10 @@
+package com.cn.tianji.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.cn.tianji.entity.YjTorqueWarnValue;
+
+import java.util.List;
+
+public interface YjTorqueWarnValueService  extends IService<YjTorqueWarnValue> {
+    List<YjTorqueWarnValue> getListByJh(String jh);
+}

yujing-common/src/main/java/com/cn/tianji/service/YjTotalPoolWarnValueService.java

@@ -0,0 +1,10 @@
+package com.cn.tianji.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.cn.tianji.entity.YjTotalPoolWarnValue;
+
+import java.util.List;
+
+public interface YjTotalPoolWarnValueService  extends IService<YjTotalPoolWarnValue> {
+    List<YjTotalPoolWarnValue> getListByJh(String jh);
+}

yujing-common/src/main/java/com/cn/tianji/service/YjWohWarnValueService.java

@@ -0,0 +1,8 @@
+package com.cn.tianji.service;
+
+import com.baomidou.mybatisplus.extension.service.IService;
+import com.cn.tianji.entity.YjWohWarnValue;
+
+public interface YjWohWarnValueService  extends IService<YjWohWarnValue> {
+    YjWohWarnValue getOneDataByJh(String jh);
+}

yujing-common/src/main/java/com/cn/tianji/service/impl/YjDrillingDataSupplementationLogServiceImpl.java

@@ -0,0 +1,11 @@
+package com.cn.tianji.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.cn.tianji.entity.YjDrillingDataSupplementationLog;
+import com.cn.tianji.mapper.YjDrillingDataSupplementationLogMapper;
+import com.cn.tianji.service.YjDrillingDataSupplementationLogService;
+import org.springframework.stereotype.Service;
+
+@Service
+public class YjDrillingDataSupplementationLogServiceImpl extends ServiceImpl<YjDrillingDataSupplementationLogMapper, YjDrillingDataSupplementationLog> implements YjDrillingDataSupplementationLogService {
+}

yujing-common/src/main/java/com/cn/tianji/service/impl/YjPumpingWarnValueServiceImpl.java

@@ -0,0 +1,58 @@
+package com.cn.tianji.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.cn.tianji.entity.YjPumpingWarnValue;
+import com.cn.tianji.mapper.YjPumpingWarnValueMapper;
+import com.cn.tianji.service.YjPumpingWarnValueService;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 泵压预警阈值;(yj_pumping_warn_value)表服务实现类
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@Service
+public class YjPumpingWarnValueServiceImpl extends ServiceImpl<YjPumpingWarnValueMapper, YjPumpingWarnValue> implements YjPumpingWarnValueService {
+
+
+    @Override
+    public  List<YjPumpingWarnValue> getListByJh(String jh){
+        QueryWrapper<YjPumpingWarnValue> wrapper=new QueryWrapper<>();
+        wrapper.lambda().eq(YjPumpingWarnValue::getJh,jh);
+        wrapper.lambda().orderByAsc(YjPumpingWarnValue::getSortCode);
+        List<YjPumpingWarnValue> list = this.list(wrapper);
+        if(list.size()==0){
+            list = createList(jh);
+            this.saveBatch(list);
+        }
+        return list;
+    }
+
+    public  List<YjPumpingWarnValue> createList(String jh){
+        List<YjPumpingWarnValue> list =new ArrayList<>();
+        YjPumpingWarnValue model=new YjPumpingWarnValue();
+        model.setJh(jh);
+        model.setSortCode(1);
+        model.setPumpingMin(BigDecimal.valueOf(0));
+        model.setPumpingMax(BigDecimal.valueOf(30));
+        model.setPumpingWarnValue(BigDecimal.valueOf(0.05));
+        model.setSppWarnValue(BigDecimal.valueOf(0.1));
+        model.setBitdepth(BigDecimal.valueOf(500));
+        YjPumpingWarnValue model1=new YjPumpingWarnValue();
+        model1.setJh(jh);
+        model1.setSortCode(2);
+        model1.setPumpingMin(BigDecimal.valueOf(30));
+        model1.setPumpingMax(BigDecimal.valueOf(0));
+        model1.setPumpingWarnValue(BigDecimal.valueOf(0.05));
+        model1.setSppWarnValue(BigDecimal.valueOf(0.05));
+        model1.setBitdepth(BigDecimal.valueOf(500));
+        list.add(model);
+        list.add(model1);
+        return list;
+    }
+}

yujing-common/src/main/java/com/cn/tianji/service/impl/YjRealTimeLogServiceImpl.java

@@ -0,0 +1,117 @@
+package com.cn.tianji.service.impl;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.cn.tianji.common.StringUtils;
+import com.cn.tianji.entity.YjRealTimeLog;
+import com.cn.tianji.mapper.YjRealTimeLogMapper;
+import com.cn.tianji.service.WellDrillingService;
+import com.cn.tianji.service.YjDrillingDataSupplementationLogService;
+import com.cn.tianji.service.YjRealTimeLogService;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.text.ParseException;
+import java.text.SimpleDateFormat;
+import java.time.Duration;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+
+@Service
+public class YjRealTimeLogServiceImpl extends ServiceImpl<YjRealTimeLogMapper, YjRealTimeLog> implements YjRealTimeLogService {
+
+    @Resource
+    private YjRealTimeLogMapper mapper;
+
+    @Resource
+    private WellDrillingService wellDrillingService;
+
+    DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
+
+    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+
+
+    @Override
+    public void saveRealTimeLog(List<String> jhLit) {
+        //清空表数据
+        mapper.truncateTable();
+        List<YjRealTimeLog> saveList = new ArrayList<>();
+        jhLit.forEach(item -> {
+            YjRealTimeLog saveModel = new YjRealTimeLog();
+            saveModel.setJh(item);
+            String jhTable = "LTD_" + item.replace('-', '_').toUpperCase().trim();
+            String selectJh = "\"" + jhTable + "\"";
+            String lastDate = wellDrillingService.getLastDateByJh(selectJh);
+            if (!StringUtils.isEmpty(lastDate)) {
+                lastDate = lastDate.contains(".") ? lastDate.substring(0, lastDate.indexOf(".")) : lastDate;
+                Date lastDateTime = null;
+                try {
+                    lastDateTime = sdf.parse(lastDate);
+                } catch (ParseException e) {
+                    e.printStackTrace();
+                }
+                Date nowTime = new Date();
+                saveModel.setRealTime(lastDateTime);
+                saveModel.setCreateTime(nowTime);
+                long l = calculateMinutesDifference(lastDateTime, nowTime);
+                if (l > 30) {
+                    saveModel.setStatus("离线");
+                } else {
+                    saveModel.setStatus("在线");
+                }
+            }
+            saveList.add(saveModel);
+        });
+        this.saveBatch(saveList);
+    }
+
+    /**
+     * 计算两个LocalDateTime对象之间的分钟数差异
+     *
+     * @param startTime 开始时间
+     * @param endTime   结束时间
+     * @return 小时数差异
+     */
+    public static long calculateMinutesDifference(Date startTime, Date endTime) {
+        long duration = endTime.getTime()-startTime.getTime();
+        long minutes = (duration % (1000 * 60 * 60)) / (1000 * 60);
+        return minutes; // 返回总小时数差异
+    }
+
+
+    /**
+     * 批量更新实时井状态
+     */
+    @Override
+    public void updateBatchJhStatus() {
+        List<YjRealTimeLog> list = this.list();
+        if (list.size() > 0) {
+            list.forEach(item -> {
+                String jh = item.getJh();
+                String jhTable = "LTD_" + jh.replace('-', '_').toUpperCase().trim();
+                String selectJh = "\"" + jhTable + "\"";
+                String lastDate = wellDrillingService.getLastDateByJh(selectJh);
+                if(!StringUtils.isEmpty(lastDate)){
+                    Date lastTime = null;
+                    try {
+                        lastTime = sdf.parse(lastDate);
+                    } catch (ParseException e) {
+                        e.printStackTrace();
+                    }
+                    item.setRealTime(lastTime);
+                    Date nowTime = new Date();
+                    long l = calculateMinutesDifference(lastTime, nowTime);
+                    if (l > 10) {
+                        item.setStatus("离线");
+                    } else {
+                        item.setStatus("在线");
+                    }
+                }
+            });
+            this.updateBatchById(list);
+        }
+    }
+}

yujing-common/src/main/java/com/cn/tianji/service/impl/YjTorqueWarnValueServiceImpl.java

@@ -0,0 +1,49 @@
+package com.cn.tianji.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.cn.tianji.entity.YjTorqueWarnValue;
+import com.cn.tianji.mapper.YjTorqueWarnValueMapper;
+import com.cn.tianji.service.YjTorqueWarnValueService;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 扭矩预警阈值;(yj_torque_warn_value)表服务实现类
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@Service
+public class YjTorqueWarnValueServiceImpl extends ServiceImpl<YjTorqueWarnValueMapper, YjTorqueWarnValue> implements YjTorqueWarnValueService {
+
+
+    @Override
+    public List<YjTorqueWarnValue> getListByJh(String jh){
+        QueryWrapper<YjTorqueWarnValue> wrapper=new QueryWrapper<>();
+        wrapper.lambda().eq(YjTorqueWarnValue::getJh,jh);
+        wrapper.lambda().orderByAsc(YjTorqueWarnValue::getSortCode);
+        List<YjTorqueWarnValue> list = this.list(wrapper);
+        if(list.size()==0){
+            list = createList(jh);
+            this.saveBatch(list);
+        }
+        return list;
+    }
+
+    public List<YjTorqueWarnValue> createList(String jh){
+        List<YjTorqueWarnValue> list = new ArrayList<>();
+        YjTorqueWarnValue model=new YjTorqueWarnValue();
+        model.setJh(jh);
+        model.setBitdepth(BigDecimal.valueOf(500));
+        model.setTorqueMin(BigDecimal.valueOf(0));
+        model.setTorqueMax(BigDecimal.valueOf(0));
+        model.setVarianceWarnValue(BigDecimal.valueOf(0.2));
+        model.setFluctuateWarn(BigDecimal.valueOf(1));
+        model.setSortCode(1);
+        list.add(model);
+        return list;
+    }
+}

yujing-common/src/main/java/com/cn/tianji/service/impl/YjTotalPoolWarnValueServiceImpl.java

@@ -0,0 +1,54 @@
+package com.cn.tianji.service.impl;
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.cn.tianji.entity.YjTotalPoolWarnValue;
+import com.cn.tianji.mapper.YjTotalPoolWarnValueMapper;
+import com.cn.tianji.service.YjTotalPoolWarnValueService;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * 总池体积预警阈值;(yj_total_pool_warn_value)表服务实现类
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@Service
+public class YjTotalPoolWarnValueServiceImpl extends ServiceImpl<YjTotalPoolWarnValueMapper, YjTotalPoolWarnValue> implements YjTotalPoolWarnValueService {
+
+
+    @Override
+    public  List<YjTotalPoolWarnValue> getListByJh(String jh){
+        QueryWrapper<YjTotalPoolWarnValue> wrapper=new QueryWrapper<>();
+        wrapper.lambda().eq(YjTotalPoolWarnValue::getJh,jh);
+        List<YjTotalPoolWarnValue> list = this.list(wrapper);
+        if(list.size()==0){
+            list = createList(jh);
+            this.saveBatch(list);
+        }
+        return list;
+    }
+
+    public List<YjTotalPoolWarnValue> createList(String jh){
+        List<YjTotalPoolWarnValue> list =new ArrayList<>();
+        YjTotalPoolWarnValue model=new YjTotalPoolWarnValue();
+        model.setJh(jh);
+        model.setWarnType("井漏");
+        model.setBitdepth(BigDecimal.valueOf(500));
+        model.setPittotalWarn(BigDecimal.valueOf(-2));
+        model.setRanteWarn(BigDecimal.valueOf(-1));
+
+        YjTotalPoolWarnValue model1=new YjTotalPoolWarnValue();
+        model1.setJh(jh);
+        model1.setWarnType("溢流");
+        model1.setBitdepth(BigDecimal.valueOf(500));
+        model1.setPittotalWarn(BigDecimal.valueOf(1));
+        model1.setRanteWarn(BigDecimal.valueOf(0.5));
+        list.add(model);
+        list.add(model1);
+        return list;
+    }
+}

yujing-common/src/main/java/com/cn/tianji/service/impl/YjWohWarnValueServiceImpl.java

@@ -0,0 +1,44 @@
+package com.cn.tianji.service.impl;
+
+import cn.hutool.core.util.ObjectUtil;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.cn.tianji.entity.YjWohWarnValue;
+import com.cn.tianji.mapper.YjWohWarnValueMapper;
+import com.cn.tianji.service.YjWohWarnValueService;
+import org.springframework.stereotype.Service;
+
+import java.math.BigDecimal;
+
+/**
+ * 钩载预警阈值管理;(yj_woh_warn_value)表服务实现类
+ * @author : http://www.chiner.pro
+ * @date : 2025-1-7
+ */
+@Service
+public class YjWohWarnValueServiceImpl extends ServiceImpl<YjWohWarnValueMapper, YjWohWarnValue> implements YjWohWarnValueService {
+
+
+    @Override
+    public YjWohWarnValue getOneDataByJh(String jh){
+        QueryWrapper<YjWohWarnValue> wrapper=new QueryWrapper<>();
+        wrapper.lambda().eq(YjWohWarnValue::getJh,jh);
+        YjWohWarnValue one = this.getOne(wrapper);
+        if(ObjectUtil.isEmpty(one)){
+            one = createModel(jh);
+            this.save(one);
+        }
+        return one;
+    }
+
+    public YjWohWarnValue createModel(String jh){
+        YjWohWarnValue model=new YjWohWarnValue();
+        model.setJh(jh);
+        model.setBitdepth(BigDecimal.valueOf(500));
+        model.setRodWeight(BigDecimal.valueOf(7.73));
+        model.setSustainWoh(BigDecimal.valueOf(100));
+        model.setActivityOne(BigDecimal.valueOf(100));
+        model.setActivityTwo(BigDecimal.valueOf(30));
+        return model;
+    }
+}

yujing-common/src/main/java/com/cn/tianji/util/CommonUtil.java

@@ -208,4 +208,18 @@ public class CommonUtil {
         }
         return result;
     }
+
+    public static <T> List<T> castList(Object obj, Class<T> clazz)
+    {
+        List<T> result = new ArrayList<T>();
+        if(obj instanceof List<?>)
+        {
+            for (Object o : (List<?>) obj)
+            {
+                result.add(clazz.cast(o));
+            }
+            return result;
+        }
+        return null;
+    }
 }

yujing-common/src/main/resources/mapper/YjDrillingDataSupplementationLogMapper.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.cn.tianji.mapper.YjDrillingDataSupplementationLogMapper">
+
+</mapper>

yujing-common/src/main/resources/mapper/YjPumpingWarnValueMapper.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.cn.tianji.mapper.YjPumpingWarnValueMapper">
+
+</mapper>

yujing-common/src/main/resources/mapper/YjRealTimeLogMapper.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.cn.tianji.mapper.YjRealTimeLogMapper">
+
+    <update id="truncateTable" >
+        TRUNCATE TABLE YJ_REAL_TIME_LOG
+    </update>
+
+</mapper>

yujing-common/src/main/resources/mapper/YjTorqueWarnValueMapper.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.cn.tianji.mapper.YjTorqueWarnValueMapper">
+
+</mapper>

yujing-common/src/main/resources/mapper/YjTotalPoolWarnValueMapper.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.cn.tianji.mapper.YjTotalPoolWarnValueMapper">
+</mapper>

yujing-common/src/main/resources/mapper/YjWohWarnValueMapper.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+
+<mapper namespace="com.cn.tianji.mapper.YjWohWarnValueMapper">
+
+</mapper>

yujing-condition-identification/src/main/java/com/cn/tianji/controller/WorkingConditionCalculationController.java

@@ -20,4 +20,6 @@ public class WorkingConditionCalculationController {
     public Result<?> workingConditionCalculation(@RequestParam("workingConditionCalculationLogId") String workingConditionCalculationLogId){
        return workingConditionCalculationService.workingConditionCalculation(workingConditionCalculationLogId);
     }
+
+
 }

yujing-condition-identification/src/main/java/com/cn/tianji/service/Impl/WorkingConditionCalculationServiceImpl.java

@@ -8,6 +8,7 @@ import com.cn.tianji.common.Result;
 import com.cn.tianji.dto.ConditionDeterminationDto;
 import com.cn.tianji.entity.*;
 import com.cn.tianji.service.*;
+import com.cn.tianji.util.CommonUtil;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.scheduling.annotation.Async;
@@ -15,12 +16,14 @@ import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
 import java.math.BigDecimal;
+import java.math.RoundingMode;
 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
 
 @Service
 @Slf4j
@@ -65,6 +68,16 @@ public class WorkingConditionCalculationServiceImpl implements WorkingConditionC
     private TorqueWarnLogService torqueWarnLogService;
 
     @Resource
+    private YjWohWarnValueService wohWarnValueService;
+
+    @Resource
+    private YjTorqueWarnValueService torqueWarnValueService;
+
+    @Resource
+    private YjPumpingWarnValueService pumpingWarnValueService;
+
+
+    @Resource
     private RedisUtil redisUtil;
     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
@@ -76,11 +89,11 @@ public class WorkingConditionCalculationServiceImpl implements WorkingConditionC
     @Override
     public Result<?> workingConditionCalculation(String workingConditionCalculationLogId) {
         WorkingConditionCalculationLog workingConditionCalculationLogModel = workingConditionCalculationLogService.getById(workingConditionCalculationLogId);
-        String jh= workingConditionCalculationLogModel.getJh();
+        String jh = workingConditionCalculationLogModel.getJh();
         String startTime = workingConditionCalculationLogModel.getStartTime();
         String endTime = workingConditionCalculationLogModel.getEndTime();
         String calculateType = workingConditionCalculationLogModel.getCalculateType();
-         String isDelRedis=workingConditionCalculationLogModel.getIsDelRedis();
+        String isDelRedis = workingConditionCalculationLogModel.getIsDelRedis();
         Result<Object> res = new Result<>();
         switch (calculateType) {
             case "0":
@@ -161,10 +174,10 @@ public class WorkingConditionCalculationServiceImpl implements WorkingConditionC
             ConditionDeterminationDto conditionDeterminationDto = conditionIdentificationService.conditionDetermination(calList, one);
             nowPoint.setMotion(conditionDeterminationDto.getMotion());
             nowPoint.setOperatingMode(conditionDeterminationDto.getOperatingMode());
-            log.info("更新点位时间:{};工况:{},动作:{}",nowPoint.getTime(),nowPoint.getMotion(),nowPoint.getOperatingMode());
+            log.info("更新点位时间:{};工况:{},动作:{}", nowPoint.getTime(), nowPoint.getMotion(), nowPoint.getOperatingMode());
             QueryWrapper<WellDrilling> wrapper1 = new QueryWrapper<>();
             wrapper1.apply("TO_DATE(SUBSTR(TIME, 1, 19), 'yyyy-MM-dd HH24:mi:ss') = to_date({0},'yyyy-mm-dd hh24:mi:ss')", nowPoint.getTime());
-            wellDrillingService.updateByTimeOrcale(jhTableName,conditionDeterminationDto.getMotion(), conditionDeterminationDto.getOperatingMode(), wrapper1);
+            wellDrillingService.updateByTimeOrcale(jhTableName, conditionDeterminationDto.getMotion(), conditionDeterminationDto.getOperatingMode(), wrapper1);
             if ("1".equals(workingConditionCalculationLogModel.getIsCalculate())) {
                 workingConditionCalculationLogModel.setIsCalculate("2");
             }
@@ -218,12 +231,12 @@ public class WorkingConditionCalculationServiceImpl implements WorkingConditionC
                 log.info("钩载预警计算,当前点井深{};时间:{}", nowPoint.getBitdepth(), nowPoint.getTime());
                 if ("起下钻".equals(operatingMode)) {
                     redisHasKey = jh + "_hook_load_recalculate";
-                    drillingOutHookLoadService.hookLoadWarnCalculate(nowPoint, redisHasKey, warnValue, rodWeight);
+                    // drillingOutHookLoadService.hookLoadWarnCalculate(nowPoint, redisHasKey, warnValue, rodWeight);
                 } else {
                     redisHasKey = jh + "_drilling_hook_load_recalculate";
                     drillingHookloadService.hookLoadWarnCalculate(nowPoint, redisHasKey, warnValue);
                 }
-            }else {
+            } else {
                 log.info("钩载预警计算,钻头位置小于500米;当前点井深{};时间:{}", nowPoint.getBitdepth(), nowPoint.getTime());
             }
             if ("1".equals(workingConditionCalculationLogModel.getIsCalculate())) {
@@ -274,11 +287,11 @@ public class WorkingConditionCalculationServiceImpl implements WorkingConditionC
             BigDecimal bitdepth = nowPoint.getBitdepth();
             int bitdepthThreshold = bitdepth.compareTo(BigDecimal.valueOf(500));
             if (bitdepthThreshold >= 0) {
-                try {
-                    totalPoolVolumeService.totalPoolVolumeWarn(nowPoint, redisHasKey);
-                } catch (ParseException e) {
-                    e.printStackTrace();
-                }
+//                try {
+//                    totalPoolVolumeService.totalPoolVolumeWarn(nowPoint, redisHasKey);
+//                } catch (ParseException e) {
+//                    e.printStackTrace();
+//                }
             }
             if ("1".equals(workingConditionCalculationLogModel.getIsCalculate())) {
                 workingConditionCalculationLogModel.setIsCalculate("2");
@@ -321,10 +334,19 @@ public class WorkingConditionCalculationServiceImpl implements WorkingConditionC
         }
         for (int i = 0; i < list.size() - 1; i++) {
             WellDrilling nowPoint = list.get(i);
+            BigDecimal nowSpp = nowPoint.getSpp().setScale(2, RoundingMode.HALF_UP);
+            List<YjPumpingWarnValue> warnValueDatas = getPumpWarnValues(jh);
+            YjPumpingWarnValue warnValueData = filterPumpWarnData(nowSpp, warnValueDatas);
+            log.info("筛选后的阈值数据:{}",warnValueData);
+            BigDecimal pumpingWarnValue = warnValueData.getPumpingWarnValue();
+            BigDecimal sppWarnValue = warnValueData.getSppWarnValue();
+            BigDecimal warnBitdepth = warnValueData.getBitdepth();
             BigDecimal bitdepth = nowPoint.getBitdepth();
-            int bitdepthThreshold = bitdepth.compareTo(BigDecimal.valueOf(500));
+            log.info("当前点井深{};阈值井深:{},时间:{}", nowPoint.getBitdepth(), warnBitdepth, nowPoint.getTime());
+            int bitdepthThreshold = bitdepth.compareTo(warnBitdepth);
             if (bitdepthThreshold >= 0) {
-                pumpingPressureService.pumpingPressureCalculate(nowPoint, redisHasKey);
+                pumpingPressureService.pumpingPressureCalculate(nowPoint, redisHasKey, pumpingWarnValue, sppWarnValue);
+                //pumpingPressureService.pumpingPressureCalculate(nowPoint, redisHasKey);
             }
             if ("1".equals(workingConditionCalculationLogModel.getIsCalculate())) {
                 workingConditionCalculationLogModel.setIsCalculate("2");
@@ -367,13 +389,21 @@ public class WorkingConditionCalculationServiceImpl implements WorkingConditionC
 
         for (int i = 0; i < list.size() - 1; i++) {
             WellDrilling nowPoint = list.get(i);
+            BigDecimal torque = nowPoint.getTorque();
+            List<YjTorqueWarnValue> warnValueDatas = getWarnValues(jh);
+            YjTorqueWarnValue yjTorqueWarnValue = filterWarnData(torque, warnValueDatas);
+            BigDecimal warnBitdepth = yjTorqueWarnValue.getBitdepth();
+            //均值预警值
+            BigDecimal varianceWarnValue = yjTorqueWarnValue.getVarianceWarnValue();
+            //波动值预警值
+            BigDecimal fluctuateWarn = yjTorqueWarnValue.getFluctuateWarn();
             BigDecimal bitdepth = nowPoint.getBitdepth();
-            int bitdepthThreshold = bitdepth.compareTo(BigDecimal.valueOf(500));
+            log.info("当前点井深{};阈值井深:{},时间:{}", nowPoint.getBitdepth(), warnBitdepth, nowPoint.getTime());
+            int bitdepthThreshold = bitdepth.compareTo(warnBitdepth);
             if (bitdepthThreshold >= 0) {
-                log.info("当前点井深{};时间:{}", nowPoint.getBitdepth(), nowPoint.getTime());
-                BigDecimal varianceWarnValue = BigDecimal.valueOf(0.5);
-                BigDecimal fluctuateWarn = BigDecimal.valueOf(0.5);
-                torqueService.torqueCalculate(nowPoint, redisHasKey,varianceWarnValue,fluctuateWarn);
+//                BigDecimal varianceWarnValue = BigDecimal.valueOf(0.5);
+//                BigDecimal fluctuateWarn = BigDecimal.valueOf(0.5);
+                torqueService.torqueCalculate(nowPoint, redisHasKey, varianceWarnValue, fluctuateWarn);
             } else {
                 log.info("钻头位置小于500米;当前点井深{};时间:{}", nowPoint.getBitdepth(), nowPoint.getTime());
             }
@@ -402,4 +432,113 @@ public class WorkingConditionCalculationServiceImpl implements WorkingConditionC
 //
 //    }
 
+
+    public String warnTorqueValueKey = "_torque_warn_value_con_key";
+
+    public List<YjTorqueWarnValue> getWarnValues(String jh) {
+        String warnKey = jh + warnTorqueValueKey;
+        boolean isWarnKey = redisUtil.hasKey(warnKey);
+        List<YjTorqueWarnValue> list = new ArrayList<>();
+        if (isWarnKey) {
+            Object o = redisUtil.get(warnKey);
+            list = CommonUtil.castList(o, YjTorqueWarnValue.class);
+        } else {
+            list = torqueWarnValueService.getListByJh(jh);
+            redisUtil.set(warnKey, list);
+        }
+        return list;
+    }
+
+    /**
+     * @param nowTorque
+     * @param warnValueDatas
+     */
+    public YjTorqueWarnValue filterWarnData(BigDecimal nowTorque, List<YjTorqueWarnValue> warnValueDatas) {
+        AtomicReference<YjTorqueWarnValue> model = new AtomicReference<>(new YjTorqueWarnValue());
+        log.info("筛选的阈值数组:{}", warnValueDatas);
+        log.info("当前点扭矩：{}", nowTorque);
+        warnValueDatas.forEach(item -> {
+            BigDecimal torqueMin = item.getTorqueMin();
+            BigDecimal torqueMax = item.getTorqueMax();
+            Boolean minIsZero = torqueMin.compareTo(BigDecimal.ZERO) <= 0;
+            boolean maxIsZero = torqueMax.compareTo(BigDecimal.ZERO) > 0;
+            boolean isMin = nowTorque.compareTo(torqueMin) > 0;
+            boolean isMax = nowTorque.compareTo(torqueMax) <= 0;
+            log.info("最小值是否小于等于0：{}", minIsZero);
+            log.info("最大值是否大于0：{}", maxIsZero);
+            log.info("是否小于等于最大值：{};最大值：{}", isMax, torqueMax);
+            log.info("是否大于最小值：{};最小值：{}", isMin, torqueMin);
+            if (minIsZero) {
+                model.set(warnValueDatas.get(0));
+            } else {
+                if (maxIsZero) {
+                    if (isMin && isMax) {
+                        model.set(item);
+                    }
+                } else {
+                    if (isMin) {
+                        model.set(item);
+                    }
+                }
+            }
+        });
+        log.info("筛选的阈值结果:{}", model.get());
+        return model.get();
+    }
+
+    public String warnPumpValueKey = "_pump_warn_value_con_key";
+
+    public List<YjPumpingWarnValue> getPumpWarnValues(String jh) {
+        String warnKey = jh + warnPumpValueKey;
+        boolean isWarnKey = redisUtil.hasKey(warnKey);
+        List<YjPumpingWarnValue> list = new ArrayList<>();
+        if (isWarnKey) {
+            Object o = redisUtil.get(warnKey);
+            list = CommonUtil.castList(o, YjPumpingWarnValue.class);
+        } else {
+            list = pumpingWarnValueService.getListByJh(jh);
+            redisUtil.set(warnKey, list);
+        }
+        return list;
+    }
+
+
+    /**
+     * @param nowSpp
+     * @param warnValueDatas
+     */
+    public YjPumpingWarnValue filterPumpWarnData(BigDecimal nowSpp, List<YjPumpingWarnValue> warnValueDatas) {
+        AtomicReference<YjPumpingWarnValue> model = new AtomicReference<>(new YjPumpingWarnValue());
+        log.info("当前点立压：{}", nowSpp);
+        warnValueDatas.forEach(item -> {
+            BigDecimal pumpingMin = item.getPumpingMin();
+            BigDecimal pumpingMax = item.getPumpingMax();
+            Boolean minIsZero = pumpingMin.compareTo(BigDecimal.ZERO) <= 0;
+            Boolean maxIsZero = pumpingMax.compareTo(BigDecimal.ZERO) > 0;
+            boolean isMin = nowSpp.compareTo(pumpingMin) > 0;
+            boolean isMax = nowSpp.compareTo(pumpingMax) <= 0;
+            log.info("最小值是否小于等于0：{}", minIsZero);
+            log.info("最大值是否大于0：{}", maxIsZero);
+            log.info("是否小于等于最大值：{};最大值：{}", isMax, pumpingMax);
+            log.info("是否大于最小值：{};最小值：{}", isMin, pumpingMin);
+            if (minIsZero) {
+                model.set(warnValueDatas.get(0));
+            } else {
+                if (maxIsZero) {
+                    if (isMin && isMax) {
+                        model.set(item);
+                    }
+                } else {
+                    if (isMin) {
+                        log.info("最小值:{}",pumpingMin);
+                        log.info("阈值数据:{}",item);
+                        model.set(item);
+                    }
+                }
+            }
+        });
+        YjPumpingWarnValue yjPumpingWarnValue = model.get();
+        return yjPumpingWarnValue;
+    }
+
 }

yujing-hook-load-warning/src/main/java/com/cn/tianji/service/impl/HookLoadServiceImpl.java

@@ -1,12 +1,17 @@
 package com.cn.tianji.service.impl;
 
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.cn.tianji.common.DrillingOutHookLoadCatch;
 import com.cn.tianji.common.RedisUtil;
 import com.cn.tianji.entity.HookLoadWarnLog;
 import com.cn.tianji.entity.WellDrilling;
+import com.cn.tianji.entity.YjWohWarnValue;
 import com.cn.tianji.service.DrillingOutHookLoadService;
 import com.cn.tianji.service.HookLoadService;
 import com.cn.tianji.service.HookLoadWarnLogService;
+import com.cn.tianji.service.YjWohWarnValueService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 import org.springframework.web.bind.annotation.RequestParam;
@@ -26,24 +31,31 @@ public class HookLoadServiceImpl implements HookLoadService {
     @Resource
     private DrillingOutHookLoadService drillingOutHookLoadService;
 
+    @Resource
+    private YjWohWarnValueService wohWarnValueService;
 
     @Resource
     private RedisUtil redisUtil;
 
     //抽取钻井、起下钻中的动作 按照动作走判断方法
 
+    public String warnValueKey="_woh_warn_value_key";
+
     @Override
     public void hookLoadWarn(WellDrilling nowPoint){
         String jh = nowPoint.getJh();
+        YjWohWarnValue warnValueData = getWarnValue(jh);
         //String motion = nowPoint.getMotion();
         String redisHasKey = jh + "_hook_load_real_time_computing";
         log.info("接收的数据:井号:{} 时间:{}",jh,nowPoint.getTime());
-        BigDecimal warnValue = BigDecimal.valueOf(100);
-        BigDecimal rodWeight = BigDecimal.valueOf(7.73);
+        BigDecimal warnValue =warnValueData.getSustainWoh();// BigDecimal.valueOf(100);
+        BigDecimal rodWeight = warnValueData.getRodWeight();// BigDecimal.valueOf(7.73);
+        BigDecimal activityOne = warnValueData.getActivityOne();
+        BigDecimal activityTwo = warnValueData.getActivityTwo();
         BigDecimal bitdepth = nowPoint.getBitdepth();
-        int isIntoButtom = bitdepth.compareTo(BigDecimal.valueOf(500));
+        int isIntoButtom = bitdepth.compareTo(warnValueData.getBitdepth());
         if(isIntoButtom>0){
-            drillingOutHookLoadService.hookLoadWarnCalculate(nowPoint,redisHasKey,warnValue,rodWeight);
+            drillingOutHookLoadService.hookLoadWarnCalculate(nowPoint,redisHasKey,warnValue,rodWeight, activityOne,activityTwo);
         }else{
             boolean b = redisUtil.hasKey(redisHasKey);
             if(b){
@@ -53,4 +65,19 @@ public class HookLoadServiceImpl implements HookLoadService {
     }
 
 
+    public YjWohWarnValue getWarnValue(String jh){
+        String warnKey=jh+warnValueKey;
+        boolean isWarnKey = redisUtil.hasKey(warnKey);
+        YjWohWarnValue yjWohWarnValue =null;
+        if(isWarnKey){
+            Object o = redisUtil.get(warnKey);
+            yjWohWarnValue = JSON.parseObject(JSON.toJSONString(o),YjWohWarnValue.class);
+            //JSONObject.toJavaObject(JSONObject.parseObject(JSON.toJSONString(o)), YjWohWarnValue.class);
+        }else{
+            yjWohWarnValue = wohWarnValueService.getOneDataByJh(jh);
+            redisUtil.set(warnKey,yjWohWarnValue);
+        }
+        return yjWohWarnValue;
+    }
+
 }

yujing-pull/src/main/java/com/cn/tianji/service/impl/BizServiceImpl.java

@@ -93,6 +93,8 @@ public class BizServiceImpl implements BizService {
     @Resource
     private AjhService ajhService;
 
+    @Resource
+    private YjRealTimeLogService yjRealTimeLogService;
     //@Scheduled(fixedDelay = 30L, timeUnit = TimeUnit.MINUTES)
     @Override
     public void syncTables() throws InterruptedException {
@@ -820,6 +822,9 @@ public class BizServiceImpl implements BizService {
                 .collect(Collectors.toList());
         //更新创建井表
         this.createTable(jhList);
+        jhList.add("顺深2斜");
+        //更新实时数据表
+        yjRealTimeLogService.saveRealTimeLog(jhList);
         return jhJsonArray;
     }
 

yujing-pull/src/main/java/com/cn/tianji/service/impl/PullSICPDataServiceImpl.java

@@ -166,7 +166,6 @@ public class PullSICPDataServiceImpl implements PullSICPDataService {
             LocalDateTime formatTime = LocalDateTime.parse(lastDate, df);
             Duration duration = Duration.between(formatTime, now);
             long timeDiff = duration.toMinutes();
-
             if(timeDiff>1){
                 pullDataByJh(item,lastDate);
             }

yujing-pull/src/main/java/com/cn/tianji/task/PullDataTask.java

@@ -2,6 +2,7 @@ package com.cn.tianji.task;
 
 import com.alibaba.fastjson.JSONArray;
 import com.cn.tianji.service.BizService;
+import com.cn.tianji.service.YjRealTimeLogService;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.stereotype.Component;
@@ -27,6 +28,9 @@ public class PullDataTask {
     @Resource
     private BizService bizService;
 
+    @Resource
+    private YjRealTimeLogService yjRealTimeLogService;
+
 //    @Scheduled(fixedDelay = 30L, timeUnit = TimeUnit.MINUTES, initialDelay = 60L)
     public void syncTables() throws InterruptedException{
         bizService.syncTables();
@@ -88,7 +92,7 @@ public class PullDataTask {
     }
 
     @PostConstruct
-    @Scheduled(fixedDelay = 15,timeUnit = TimeUnit.MINUTES,initialDelay = 30L)
+    @Scheduled(fixedDelay = 12,timeUnit = TimeUnit.HOURS,initialDelay = 30L)
     public void updateOp(){
         List<String> jhList = bizService.getJhList();
         jhList.forEach(item->{
@@ -97,7 +101,7 @@ public class PullDataTask {
     }
 
 
-    @Scheduled( cron="0/30 * * * * ?")
+    @Scheduled(fixedDelay = 30,timeUnit = TimeUnit.SECONDS,initialDelay = 30L)
     public void pullRealTimeData(){
         LocalDateTime startTime = LocalDateTime.now();
         List<String> jhList = bizService.getJhList();
@@ -109,6 +113,11 @@ public class PullDataTask {
         log.info("采集井实时数据开始时间:{};结束时间:{}",startTime,endTime);
     }
 
+    @Scheduled(fixedDelay = 30,timeUnit = TimeUnit.MINUTES,initialDelay = 30L)
+    public void updateBatchJhStatusTask(){
+        yjRealTimeLogService.updateBatchJhStatus();
+    }
+
 //    @Scheduled(fixedDelay = 15,timeUnit = TimeUnit.SECONDS,initialDelay = 30L)
 //    public void test(){
 //        List<String> jhList =new ArrayList<>();

yujing-pull/src/main/java/com/cn/tianji/task/PullSICPDataTask.java

@@ -10,6 +10,7 @@ import javax.annotation.Resource;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.TimeUnit;
 
 /**
  * 定时任务调度
@@ -46,7 +47,7 @@ public class PullSICPDataTask {
 //        }
 //    }
 
-    @Scheduled( cron="0/40 * * * * ?")
+    @Scheduled(fixedDelay = 40,timeUnit = TimeUnit.SECONDS,initialDelay = 30L)
     public void pullDataTask(){
         List<String> jhs=new ArrayList<>();
         jhs.add("顺深2斜");

yujing-pumping-pressure/src/main/java/com/cn/tianji/service/impl/PumpingPressureWarnServiceImpl.java

@@ -1,18 +1,28 @@
 package com.cn.tianji.service.impl;
 
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import com.cn.tianji.common.RedisUtil;
 import com.cn.tianji.entity.WellDrilling;
-import com.cn.tianji.service.DrillingOutHookLoadService;
+import com.cn.tianji.entity.YjPumpingWarnValue;
+import com.cn.tianji.entity.YjTotalPoolWarnValue;
 import com.cn.tianji.service.PumpingPressureService;
 import com.cn.tianji.service.PumpingPressureWarnService;
+import com.cn.tianji.service.YjPumpingWarnValueService;
+import com.cn.tianji.util.CommonUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
 import java.math.BigDecimal;
+import java.math.RoundingMode;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
- *钩载预警
+ * 钩载预警
+ *
  * @author Zhao RenJi
  */
 @Service
@@ -23,24 +33,81 @@ public class PumpingPressureWarnServiceImpl implements PumpingPressureWarnServic
     private PumpingPressureService pumpingPressureService;
 
     @Resource
+    private YjPumpingWarnValueService pumpingWarnValueService;
+
+    @Resource
     private RedisUtil redisUtil;
 
+    public String warnValueKey = "_pump_warn_value_key";
+
     @Override
-    public void pumpingPressureWarn(WellDrilling nowPoint){
+    public void pumpingPressureWarn(WellDrilling nowPoint) {
         String jh = nowPoint.getJh();
+        //当前点立压
+        BigDecimal nowSpp = nowPoint.getSpp().setScale(2, RoundingMode.HALF_UP);
         String redisHasKey = jh + "_pumping_pressure_real_time_computing";
-        BigDecimal warnValue = BigDecimal.valueOf(100);
-        BigDecimal rodWeight = BigDecimal.valueOf(7.73);
+        List<YjPumpingWarnValue> warnValueDatas = getWarnValues(jh);
+        YjPumpingWarnValue warnValueData = filterWarnData(nowSpp, warnValueDatas);
+        BigDecimal pumpingWarnValue = warnValueData.getPumpingWarnValue();
+        BigDecimal sppWarnValue = warnValueData.getSppWarnValue();
+        BigDecimal warnBitdepth = warnValueData.getBitdepth();
         BigDecimal bitdepth = nowPoint.getBitdepth();
-        int isIntoButtom = bitdepth.compareTo(BigDecimal.valueOf(500));
-        if(isIntoButtom>0){
-            pumpingPressureService.pumpingPressureCalculate(nowPoint,redisHasKey);
-        }else{
+        int isIntoButtom = bitdepth.compareTo(warnBitdepth);
+        if (isIntoButtom > 0) {
+            pumpingPressureService.pumpingPressureCalculate(nowPoint, redisHasKey, pumpingWarnValue, sppWarnValue);
+        } else {
             boolean b = redisUtil.hasKey(redisHasKey);
-            if(b){
+            if (b) {
                 redisUtil.del(redisHasKey);
             }
         }
+    }
 
+    public List<YjPumpingWarnValue> getWarnValues(String jh) {
+        String warnKey = jh + warnValueKey;
+        boolean isWarnKey = redisUtil.hasKey(warnKey);
+        List<YjPumpingWarnValue> list = new ArrayList<>();
+        if (isWarnKey) {
+            Object o = redisUtil.get(warnKey);
+            list = CommonUtil.castList(o, YjPumpingWarnValue.class);
+        } else {
+            list = pumpingWarnValueService.getListByJh(jh);
+            redisUtil.set(warnKey, list);
+        }
+        return list;
     }
+
+
+    /**
+     * @param nowSpp
+     * @param warnValueDatas
+     */
+    public YjPumpingWarnValue filterWarnData(BigDecimal nowSpp, List<YjPumpingWarnValue> warnValueDatas) {
+        AtomicReference<YjPumpingWarnValue> model = new AtomicReference<>(new YjPumpingWarnValue());
+        warnValueDatas.forEach(item -> {
+            BigDecimal pumpingMin = item.getPumpingMin();
+            BigDecimal pumpingMax = item.getPumpingMax();
+            Boolean minIsZero = pumpingMin.compareTo(BigDecimal.ZERO) <= 0;
+            Boolean maxIsZero = pumpingMax.compareTo(BigDecimal.ZERO) > 0;
+            boolean isMin = nowSpp.compareTo(pumpingMin) > 0;
+            boolean isMax = nowSpp.compareTo(pumpingMax) <= 0;
+            if (minIsZero) {
+                model.set(warnValueDatas.get(0));
+            } else {
+                if (maxIsZero) {
+                    if (isMin && isMax) {
+                        model.set(item);
+                    }
+                } else {
+                    if (isMin) {
+                        model.set(item);
+                    }
+                }
+            }
+        });
+        YjPumpingWarnValue yjPumpingWarnValue = model.get();
+        return yjPumpingWarnValue;
+    }
+
+
 }

yujing-send-message/src/main/java/com/cn/tianji/controller/PullWellDrillingDataController.java

@@ -8,6 +8,7 @@ import com.cn.tianji.entity.WellName;
 import com.cn.tianji.entity.WorkingConditionCalculationLog;
 import com.cn.tianji.service.PullWellDrillingDataService;
 import com.cn.tianji.service.PullWellDrillingSICPDataService;
+import com.cn.tianji.service.WarnSerive;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.scheduling.annotation.Scheduled;
 import org.springframework.web.bind.annotation.*;
@@ -27,6 +28,9 @@ public class PullWellDrillingDataController {
     @Resource
     private PullWellDrillingSICPDataService pullWellDrillingSICPDataService;
 
+    @Resource
+    private WarnSerive warnSerive;
+
     @GetMapping
     public Result<?> workingConditionCalculation(@RequestParam("workingConditionCalculationLogId") String workingConditionCalculationLogId){
         pullWellDrillingDataService.pullData(workingConditionCalculationLogId);
@@ -73,4 +77,10 @@ public class PullWellDrillingDataController {
         return Result.OK();
     }
 
+    @GetMapping("updateWarnDataBatch")
+    public Result<?> updateWarnDataBatch(){
+        warnSerive.updateWarnDataBatch();
+        return Result.OK();
+    }
+
 }

yujing-send-message/src/main/java/com/cn/tianji/service/WarnSerive.java

@@ -0,0 +1,5 @@
+package com.cn.tianji.service;
+
+public interface WarnSerive {
+    void updateWarnDataBatch();
+}

yujing-send-message/src/main/java/com/cn/tianji/service/impl/WarnSeriveImpl.java

@@ -0,0 +1,61 @@
+package com.cn.tianji.service.impl;
+
+import com.cn.tianji.service.*;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.List;
+
+@Service
+@Slf4j
+public class WarnSeriveImpl implements WarnSerive {
+
+    @Resource
+    private YjWohWarnValueService wohWarnValueService;
+
+    @Resource
+    private YjPumpingWarnValueService pumpingWarnValueService;
+
+    @Resource
+    private YjTorqueWarnValueService torqueWarnValueService;
+
+    @Resource
+    private YjTotalPoolWarnValueService totalPoolWarnValueService;
+
+    @Resource
+    private WellDrillingService wellDrillingService;
+
+
+    @Override
+    public void updateWarnDataBatch(){
+        List<String> tableNames = wellDrillingService.tableNames();
+        List<String> jhList = filterJh(tableNames);
+        log.info("井号数量");
+        jhList.forEach(item->{
+            String jh = getJh(item);
+            log.info("更新井号:{}",jh);
+            wohWarnValueService.getOneDataByJh(jh);
+            pumpingWarnValueService.getListByJh(jh);
+            torqueWarnValueService.getListByJh(jh);
+            totalPoolWarnValueService.getListByJh(jh);
+        });
+        log.info("更新完成");
+    }
+
+    public List<String> filterJh( List<String> jhList) {
+        jhList.remove("SYNC_RECORD");
+        jhList.remove("WELL_MATH_TIME");
+        jhList.remove("WELL_NEW_TABLE");
+        jhList.remove("WELL_MATH_UP_TIME");
+        jhList.remove("DRILLING_CONDITIONS_LOG");
+        return jhList;
+    }
+
+    public String getJh(String jhTableName) {
+        //井号预处理
+        jhTableName = jhTableName.replace("\"", "");
+        String s = jhTableName.replace('_', '-').toUpperCase();
+        return s.replace("LTD-", "");
+    }
+}

yujing-torque/src/main/java/com/cn/tianji/service/impl/TorqueWarnServiceImpl.java

@@ -1,18 +1,28 @@
 package com.cn.tianji.service.impl;
 
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import com.cn.tianji.common.RedisUtil;
 import com.cn.tianji.entity.WellDrilling;
+import com.cn.tianji.entity.YjPumpingWarnValue;
+import com.cn.tianji.entity.YjTorqueWarnValue;
 import com.cn.tianji.service.DrillingOutHookLoadService;
 import com.cn.tianji.service.TorqueService;
 import com.cn.tianji.service.TorqueWarnService;
+import com.cn.tianji.service.YjTorqueWarnValueService;
+import com.cn.tianji.util.CommonUtil;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
 import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
- *钩载预警
+ * 钩载预警
+ *
  * @author Zhao RenJi
  */
 @Service
@@ -23,25 +33,78 @@ public class TorqueWarnServiceImpl implements TorqueWarnService {
     private TorqueService torqueService;
 
     @Resource
+    private YjTorqueWarnValueService torqueWarnValueService;
+
+    @Resource
     private RedisUtil redisUtil;
 
+    public String warnValueKey = "_torque_warn_value_key";
+
     @Override
-    public void torqueWarn(WellDrilling nowPoint){
+    public void torqueWarn(WellDrilling nowPoint) {
         String jh = nowPoint.getJh();
         String redisHasKey = jh + "_torque_real_time_computing";
+        BigDecimal torque = nowPoint.getTorque();
+        List<YjTorqueWarnValue> warnValueDatas = getWarnValues(jh);
+        YjTorqueWarnValue yjTorqueWarnValue = filterWarnData(torque, warnValueDatas);
+        BigDecimal warnBitdepth = yjTorqueWarnValue.getBitdepth();
         //均值预警值
-        BigDecimal varianceWarnValue = BigDecimal.valueOf(0.2);
+        BigDecimal varianceWarnValue = yjTorqueWarnValue.getVarianceWarnValue();
         //波动值预警值
-        BigDecimal fluctuateWarn = BigDecimal.valueOf(1);
+        BigDecimal fluctuateWarn = yjTorqueWarnValue.getFluctuateWarn();
         BigDecimal bitdepth = nowPoint.getBitdepth();
-        int isIntoButtom = bitdepth.compareTo(BigDecimal.valueOf(500));
-        if(isIntoButtom>0){
-            torqueService.torqueCalculate(nowPoint,redisHasKey,varianceWarnValue,fluctuateWarn);
-        }else{
+        int isIntoButtom = bitdepth.compareTo(warnBitdepth);
+        if (isIntoButtom > 0) {
+            torqueService.torqueCalculate(nowPoint, redisHasKey, varianceWarnValue, fluctuateWarn);
+        } else {
             boolean b = redisUtil.hasKey(redisHasKey);
-            if(b){
+            if (b) {
                 redisUtil.del(redisHasKey);
             }
         }
     }
+
+    public List<YjTorqueWarnValue> getWarnValues(String jh) {
+        String warnKey = jh + warnValueKey;
+        boolean isWarnKey = redisUtil.hasKey(warnKey);
+        List<YjTorqueWarnValue> list = new ArrayList<>();
+        if (isWarnKey) {
+            Object o = redisUtil.get(warnKey);
+            list = CommonUtil.castList(o, YjTorqueWarnValue.class);
+        } else {
+            list = torqueWarnValueService.getListByJh(jh);
+            redisUtil.set(warnKey, list);
+        }
+        return list;
+    }
+
+    /**
+     * @param nowTorque
+     * @param warnValueDatas
+     */
+    public YjTorqueWarnValue filterWarnData(BigDecimal nowTorque, List<YjTorqueWarnValue> warnValueDatas) {
+        AtomicReference<YjTorqueWarnValue> model = new AtomicReference<>(new YjTorqueWarnValue());
+        warnValueDatas.forEach(item -> {
+            BigDecimal torqueMin = item.getTorqueMin();
+            BigDecimal torqueMax = item.getTorqueMax();
+            Boolean minIsZero = torqueMin.compareTo(BigDecimal.ZERO) <= 0;
+            boolean maxIsZero = torqueMax.compareTo(BigDecimal.ZERO) > 0;
+            boolean isMin = nowTorque.compareTo(torqueMin) > 0;
+            boolean isMax = nowTorque.compareTo(torqueMax) <= 0;
+            if (minIsZero) {
+                model.set(warnValueDatas.get(0));
+            } else {
+                if (maxIsZero) {
+                    if (isMin && isMax) {
+                        model.set(item);
+                    }
+                } else {
+                    if (isMin) {
+                        model.set(item);
+                    }
+                }
+            }
+        });
+        return model.get();
+    }
 }

yujing-total-pool-volume/src/main/java/com/cn/tianji/service/TotalPoolVolumeWarnService.java

@@ -3,6 +3,6 @@ package com.cn.tianji.service;
 import com.cn.tianji.entity.WellDrilling;
 
 public interface TotalPoolVolumeWarnService {
-    void warning(WellDrilling nowPoint);
+
     void totalPoolVolumeWarn(WellDrilling nowPoint);
 }

yujing-total-pool-volume/src/main/java/com/cn/tianji/service/impl/TotalPoolVolumeWarnServiceImpl.java

@@ -1,14 +1,27 @@
 package com.cn.tianji.service.impl;
 
+import com.alibaba.fastjson.JSONArray;
+import com.alibaba.fastjson.JSONObject;
 import com.cn.tianji.common.RedisUtil;
 import com.cn.tianji.entity.WellDrilling;
+import com.cn.tianji.entity.YjPumpingWarnValue;
+import com.cn.tianji.entity.YjTorqueWarnValue;
+import com.cn.tianji.entity.YjTotalPoolWarnValue;
 import com.cn.tianji.service.*;
+import com.cn.tianji.util.CommonUtil;
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import lombok.SneakyThrows;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
 import java.math.BigDecimal;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  *钩载预警
@@ -22,39 +35,25 @@ public class TotalPoolVolumeWarnServiceImpl implements TotalPoolVolumeWarnServic
     private TotalPoolVolumeService totalPoolVolumeService;
 
     @Resource
-    private DrillingOutHookLoadService drillingOutHookLoadService;
+    private YjTotalPoolWarnValueService totalPoolWarnValueService;
 
     @Resource
-    private TorqueService torqueService;
-
-    @Resource
-    private PumpingPressureService pumpingPressureService;
-    @Resource
     private RedisUtil redisUtil;
 
-    @SneakyThrows
-    @Override
-    public void warning(WellDrilling nowPoint){
-        String type=nowPoint.getOperatingMode();
-        totalPoolVolumeWarn(nowPoint);
-        if("钻进".equals(type)){
-            pumpingPressureWarn(nowPoint);
-            torqueWarn(nowPoint);
-        }else{
-            hookLoadWarn(nowPoint);
-        }
-    }
+    public String warnValueKey="_total_warn_value_key";
 
     @SneakyThrows
     @Override
     public void totalPoolVolumeWarn(WellDrilling nowPoint){
         String jh = nowPoint.getJh();
         String redisHasKey = jh + "_total_pool_volume_real_time_computing";
-        BigDecimal warnValue = BigDecimal.valueOf(100);
+        List<YjTotalPoolWarnValue> warnValueDatas = getWarnValues(jh);
+        BigDecimal warnBitdepth = warnValueDatas.get(0).getBitdepth();
+//        BigDecimal warnValue = BigDecimal.valueOf(100);
         BigDecimal bitdepth = nowPoint.getBitdepth();
-        int isIntoButtom = bitdepth.compareTo(BigDecimal.valueOf(500));
+        int isIntoButtom = bitdepth.compareTo(warnBitdepth);
         if(isIntoButtom>0){
-            totalPoolVolumeService.totalPoolVolumeWarn(nowPoint,redisHasKey);
+            totalPoolVolumeService.totalPoolVolumeWarn(nowPoint,redisHasKey,warnValueDatas);
         }else{
             boolean b = redisUtil.hasKey(redisHasKey);
             if(b){
@@ -63,56 +62,19 @@ public class TotalPoolVolumeWarnServiceImpl implements TotalPoolVolumeWarnServic
         }
     }
 
-    public void hookLoadWarn(WellDrilling nowPoint){
-        String jh = nowPoint.getJh();
-        String redisHasKey = jh + "_hook_load_real_time_computing";
-        BigDecimal warnValue = BigDecimal.valueOf(100);
-        BigDecimal rodWeight = BigDecimal.valueOf(7.73);
-        BigDecimal bitdepth = nowPoint.getBitdepth();
-        int isIntoButtom = bitdepth.compareTo(BigDecimal.valueOf(500));
-        if(isIntoButtom>0){
-            drillingOutHookLoadService.hookLoadWarnCalculate(nowPoint,redisHasKey,warnValue,rodWeight);
+    public List<YjTotalPoolWarnValue> getWarnValues(String jh){
+        String warnKey=jh+warnValueKey;
+        boolean isWarnKey = redisUtil.hasKey(warnKey);
+        List<YjTotalPoolWarnValue> list=new ArrayList<>();
+        if(isWarnKey){
+            Object o = redisUtil.get(warnKey);
+            list = CommonUtil.castList(o, YjTotalPoolWarnValue.class);
         }else{
-            boolean b = redisUtil.hasKey(redisHasKey);
-            if(b){
-                redisUtil.del(redisHasKey);
-            }
+            list=totalPoolWarnValueService.getListByJh(jh);
+            redisUtil.set(warnKey,list);
         }
-
+        return list;
     }
 
-    public void pumpingPressureWarn(WellDrilling nowPoint){
-        String jh = nowPoint.getJh();
-        String redisHasKey = jh + "_pumping_pressure_real_time_computing";
-        BigDecimal warnValue = BigDecimal.valueOf(100);
-        BigDecimal rodWeight = BigDecimal.valueOf(7.73);
-        BigDecimal bitdepth = nowPoint.getBitdepth();
-        int isIntoButtom = bitdepth.compareTo(BigDecimal.valueOf(500));
-        if(isIntoButtom>0){
-            pumpingPressureService.pumpingPressureCalculate(nowPoint,redisHasKey);
-        }else{
-            boolean b = redisUtil.hasKey(redisHasKey);
-            if(b){
-                redisUtil.del(redisHasKey);
-            }
-        }
-
-    }
 
-    public void torqueWarn(WellDrilling nowPoint){
-        String jh = nowPoint.getJh();
-        String redisHasKey = jh + "_torque_real_time_computing";
-        BigDecimal varianceWarnValue = BigDecimal.valueOf(0.5);
-        BigDecimal fluctuateWarn = BigDecimal.valueOf(0.5);
-        BigDecimal bitdepth = nowPoint.getBitdepth();
-        int isIntoButtom = bitdepth.compareTo(BigDecimal.valueOf(500));
-        if(isIntoButtom>0){
-            torqueService.torqueCalculate(nowPoint,redisHasKey,varianceWarnValue,fluctuateWarn);
-        }else{
-            boolean b = redisUtil.hasKey(redisHasKey);
-            if(b){
-                redisUtil.del(redisHasKey);
-            }
-        }
-    }
 }

yujing-warning-calculation/src/main/java/com/cn/tianji/service/DrillingOutHookLoadService.java

@@ -12,5 +12,5 @@ public interface DrillingOutHookLoadService {
      * 钩载预警计算
      * @param nowPoint 计算点位数据
      */
-    public void hookLoadWarnCalculate(WellDrilling nowPoint,String redisHasKey , BigDecimal warnValue, BigDecimal rodWeight);
+    public void hookLoadWarnCalculate(WellDrilling nowPoint,String redisHasKey , BigDecimal warnValue, BigDecimal rodWeight,BigDecimal activityOne,BigDecimal activityTwo);
 }

yujing-warning-calculation/src/main/java/com/cn/tianji/service/PumpingPressureService.java

@@ -2,6 +2,8 @@ package com.cn.tianji.service;
 
 import com.cn.tianji.entity.WellDrilling;
 
+import java.math.BigDecimal;
+
 public interface PumpingPressureService {
-     void pumpingPressureCalculate(WellDrilling nowPoint,String redisHasKey);
+     void pumpingPressureCalculate(WellDrilling nowPoint, String redisHasKey, BigDecimal pumpingWarnValue, BigDecimal sppWarnValue);
 }

yujing-warning-calculation/src/main/java/com/cn/tianji/service/TotalPoolVolumeService.java

@@ -2,10 +2,12 @@ package com.cn.tianji.service;
 
 
 import com.cn.tianji.entity.WellDrilling;
+import com.cn.tianji.entity.YjTotalPoolWarnValue;
 
 import java.text.ParseException;
+import java.util.List;
 
 public interface TotalPoolVolumeService {
 
-     void totalPoolVolumeWarn(WellDrilling nowPoint, String redisHasKey) throws ParseException;
+     void totalPoolVolumeWarn(WellDrilling nowPoint, String redisHasKey, List<YjTotalPoolWarnValue> warnValueDatas) throws ParseException;
 }

yujing-warning-calculation/src/main/java/com/cn/tianji/service/impl/ConditionDeterminationServiceImpl.java

@@ -63,6 +63,7 @@ public class ConditionDeterminationServiceImpl  implements ConditionDeterminatio
         BigDecimal bitDepthSum = bitDepthList.stream().reduce(BigDecimal.ZERO,BigDecimal::add);
         BigDecimal depthSubtract = depthSum.subtract(bitDepthSum);
         BigDecimal averageBitDepth= depthSubtract.divide(BigDecimal.valueOf(bitDepthList.size()),2, RoundingMode.HALF_UP);
+        log.info("是否离开井底:井深均值{};阈值:{}",averageBitDepth,threshold);
         int thresholdCom = averageBitDepth.compareTo(threshold);
         return thresholdCom>0;
     }

yujing-warning-calculation/src/main/java/com/cn/tianji/service/impl/DrillingOutHookLoadServiceImpl.java

@@ -65,7 +65,8 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
      * @param nowPoint 计算点位数据
      */
     @Override
-    public void hookLoadWarnCalculate(WellDrilling nowPoint, String redisHasKey, BigDecimal warnValue, BigDecimal rodWeight) {
+    public void hookLoadWarnCalculate(WellDrilling nowPoint, String redisHasKey, BigDecimal warnValue, BigDecimal rodWeight,
+                                      BigDecimal activityOne,BigDecimal activityTwo) {
         Date startTime = new Date();
 
         //1.判断当前点工况
@@ -90,7 +91,7 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
                 if (b) {
                     redisUtil.del(redisHasKey);
                 } else {
-                    warnCalculation(redisHasKey, nowPoint, rodWeight, warnValue);
+                    warnCalculation(redisHasKey, nowPoint, rodWeight, warnValue,activityOne,activityTwo);
                 }
             } else {
                 log.info("开始记录钩载数据");
@@ -126,7 +127,8 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
      * @param redisHasKey
      * @param nowPoint
      */
-    public void warnCalculation(String redisHasKey, WellDrilling nowPoint, BigDecimal rodWeight, BigDecimal warnValue) {
+    public void warnCalculation(String redisHasKey, WellDrilling nowPoint, BigDecimal rodWeight,
+                                BigDecimal warnValue,BigDecimal activityOne,BigDecimal activityTwo) {
         DrillingOutHookLoadCatch hookLoadCatch = JSONObject.toJavaObject(JSONObject.parseObject(JSON.toJSONString(redisUtil.get(redisHasKey))), DrillingOutHookLoadCatch.class);
         Integer recordingSteps = hookLoadCatch.getRecordingSteps();
         if (recordingSteps == 1) {
@@ -141,7 +143,7 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
             if (nowColumnData == null) {
                 nowColumnData = new ArrayList<>();
             }
-            hookLoadCatch = continuousTrippingCalculationRules(nowPoint, hookLoadCatch, rodWeight, warnValue);
+            hookLoadCatch = continuousTrippingCalculationRules(nowPoint, hookLoadCatch, rodWeight, warnValue,activityOne,activityTwo);
             nowColumnData = hookLoadCatch.getNowColumnData();
             //当前点是否预警点
             if (!hookLoadCatch.getIsWarnNowPoint()) {
@@ -299,10 +301,12 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
      * @param hookLoadCatch 缓存数据
      * @param rodWeight     一柱杆重
      * @param warnValue     报警阈值
+     * @param activityOne     报警阈值
+     * @param activityTwo     报警阈值
      * @return 缓存数据
      */
     public DrillingOutHookLoadCatch continuousTrippingCalculationRules(WellDrilling nowPoint, DrillingOutHookLoadCatch hookLoadCatch, BigDecimal rodWeight,
-                                                                       BigDecimal warnValue) {
+                                                                       BigDecimal warnValue ,BigDecimal activityOne,BigDecimal activityTwo) {
         int res = -1;
         BigDecimal nowPointWoh = nowPoint.getWoh();
         BigDecimal alarmReferenceValue = hookLoadCatch.getAlarmReferenceValue();
@@ -370,7 +374,7 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
                 log.info("计算公式:(上一柱钩载参考值){}-((当前点钩载){}-(钻杆重量){}={})={},报警阈值:{}", alarmReferenceValue, nowPointWoh, rodWeight, wohSubtract, alarmReferenceSubtract, warnValue);
             }
         }
-        hookLoadCatch = mobileDrillingTools(hookLoadCatch, nowPoint, isMobileDrillingTools, warnValue);
+        hookLoadCatch = mobileDrillingTools(hookLoadCatch, nowPoint, isMobileDrillingTools, activityOne,activityTwo);
         return hookLoadCatch;
     }
 
@@ -382,7 +386,8 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
      * @param isMobileDrillingTools
      * @return
      */
-    public DrillingOutHookLoadCatch mobileDrillingTools(DrillingOutHookLoadCatch hookLoadCatch, WellDrilling nowPoint, Boolean isMobileDrillingTools, BigDecimal warnValue) {
+    public DrillingOutHookLoadCatch mobileDrillingTools(DrillingOutHookLoadCatch hookLoadCatch, WellDrilling nowPoint, Boolean isMobileDrillingTools,
+                                                        BigDecimal activityOne,BigDecimal activityTwo) {
         if (isMobileDrillingTools) {
             hookLoadCatch = recordMobileDrillingToolsData(hookLoadCatch, nowPoint);
         } else {
@@ -390,7 +395,6 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
             Integer mobileDrillingToolsStep = hookLoadCatch.getMobileDrillingToolsStep();
             List<WellDrilling> referenceMobileDrillingToolsData = hookLoadCatch.getReferenceMobileDrillingToolsData();
             List<BigDecimal> referenceWohList = referenceMobileDrillingToolsData.stream().map(WellDrilling::getWoh).collect(Collectors.toList());
-            BigDecimal warnValueNew = BigDecimal.valueOf(30);
             switch (mobileDrillingToolsStep) {
                 case 0:
                     hookLoadCatch.setReferenceMobileDrillingToolsStartData(nowPoint);
@@ -400,7 +404,7 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
                     hookLoadCatch.setMobileDrillingToolsStep(2);
                     BigDecimal firstPointWohFluctuatedValue = calculateVolatility(referenceWohList);
                     hookLoadCatch.setFirstPointWohFluctuatedValue(firstPointWohFluctuatedValue);
-                    activeDrillingToolsWarnCal(nowPoint.getJh(), nowPoint.getOperatingMode(), nowPoint.getMotion(), hookLoadCatch, warnValueNew, 1);
+                    activeDrillingToolsWarnCal(nowPoint.getJh(), nowPoint.getOperatingMode(), nowPoint.getMotion(), hookLoadCatch, activityTwo, 1);
                     break;
                 case 2:
                     hookLoadCatch.setMobileDrillingToolsStartData(nowPoint);
@@ -411,10 +415,10 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
                     List<BigDecimal> wohList = mobileDrillingToolsData.stream().map(WellDrilling::getWoh).collect(Collectors.toList());
                     BigDecimal pointWohFluctuatedValue = calculateVolatility(wohList);
                     //
-                    activeDrillingToolsWarnCal(nowPoint.getJh(), nowPoint.getOperatingMode(), nowPoint.getMotion(), hookLoadCatch, warnValueNew, 2);
+                    activeDrillingToolsWarnCal(nowPoint.getJh(), nowPoint.getOperatingMode(), nowPoint.getMotion(), hookLoadCatch, activityTwo, 2);
 
                     //
-                    Boolean isWarn = mobileDrillingToolsCalculationRules(pointWohFluctuatedValue, hookLoadCatch.getFirstPointWohFluctuatedValue(), warnValue);
+                    Boolean isWarn = mobileDrillingToolsCalculationRules(pointWohFluctuatedValue, hookLoadCatch.getFirstPointWohFluctuatedValue(), activityOne);
                     hookLoadCatch.setMobileDrillingToolsStep(2);
                     if (isWarn) {
                         log.info("活动钻具预警:参考柱数据{},参考柱波动值:{},当前活动钻具数据:{},当前活动钻具波动值:{}",
@@ -427,7 +431,7 @@ public class DrillingOutHookLoadServiceImpl implements DrillingOutHookLoadServic
                         hookLoadWarnLogService.saveMobilDrillingToolsHookLoadWarnLog(nowPoint.getJh(), nowPoint.getOperatingMode(), hookLoadCatch.getWorkingCondition() + "-" + "活动钻具", nowPoint.getMotion(),
                                 mobileDrillingToolsData.get(0).getTime(), mobileDrillingToolsData.get(mobileDrillingToolsData.size() - 1).getTime(), pointWohFluctuatedValue, mobilDrillingToolsMaxWoh, mobilDrillingToolsMinWoh,
                                 referenceMobileDrillingToolsData.get(0).getTime(), referenceMobileDrillingToolsData.get(referenceMobileDrillingToolsData.size() - 1).getTime(), hookLoadCatch.getFirstPointWohFluctuatedValue(),
-                                maxReferenceWoh, minReferenceWoh, warnValue);
+                                maxReferenceWoh, minReferenceWoh, activityOne);
                     }
                     hookLoadCatch.setMobileDrillingToolsData(new ArrayList<>());
                     break;

yujing-warning-calculation/src/main/java/com/cn/tianji/service/impl/PumpingPressureServiceImpl.java

@@ -61,7 +61,7 @@ public class PumpingPressureServiceImpl implements PumpingPressureService {
      */
     @SneakyThrows
     @Override
-    public void pumpingPressureCalculate(WellDrilling nowPoint, String redisHasKey) {
+    public void pumpingPressureCalculate(WellDrilling nowPoint, String redisHasKey, BigDecimal pumpingWarnValue,BigDecimal sppWarnValue) {
         PumpingPressureCatch pumpingPressureCatch = new PumpingPressureCatch();
         String jh = nowPoint.getJh();
         Date nowDate=new Date();
@@ -139,12 +139,14 @@ public class PumpingPressureServiceImpl implements PumpingPressureService {
     }
 
     @SneakyThrows
-    public PumpingPressureCatch warnCalculate(WellDrilling perPoint, WellDrilling nowPoint, BigDecimal warnValue, BigDecimal warnValueSpp, PumpingPressureCatch pumpingPressureCatch){
+    public PumpingPressureCatch warnCalculate(WellDrilling perPoint, WellDrilling nowPoint,
+                                              BigDecimal pumpingWarnValue,BigDecimal sppWarnValue,
+                                              PumpingPressureCatch pumpingPressureCatch){
         BigDecimal perTotalPumpBig = calculateTotalPump(perPoint);
         BigDecimal totalPumpBig = calculateTotalPump(nowPoint);
         boolean isNoZero = totalPumpingIsZero(perPoint, nowPoint);
         if (isNoZero) {
-            Boolean isPumpWarn = pumpCalculate(perTotalPumpBig, totalPumpBig, warnValue);
+            Boolean isPumpWarn = pumpCalculate(perTotalPumpBig, totalPumpBig, pumpingWarnValue);
             //总泵冲是否发生变化
             if (!isPumpWarn) {
                 WellDrilling pumpChangePoint = pumpingPressureCatch.getPumpChangePoint();
@@ -154,7 +156,7 @@ public class PumpingPressureServiceImpl implements PumpingPressureService {
                     long timeDiff = CommonUtils.timeDifference(sdf.parse(pumpChangePoint.getTime()), sdf.parse(nowPoint.getTime()));
                     long timeDiffValue = 3*60;
                     if(timeDiff>=timeDiffValue){
-                        pumpingPressureCatch=  warnCal(perPoint,  nowPoint,  warnValue,  warnValueSpp,  pumpingPressureCatch, totalPumpBig, perTotalPumpBig);
+                        pumpingPressureCatch=  warnCal(perPoint,  nowPoint, pumpingWarnValue, sppWarnValue,pumpingPressureCatch, totalPumpBig, perTotalPumpBig);
                     }else{
                         List<WellDrilling> perPointList = pumpingPressureCatch.getPerPoint();
                         perPointList.remove(0);
@@ -162,7 +164,7 @@ public class PumpingPressureServiceImpl implements PumpingPressureService {
                         pumpingPressureCatch.setPerPoint(perPointList);
                     }
                 }else{
-                    pumpingPressureCatch= warnCal(perPoint,  nowPoint,  warnValue,  warnValueSpp,  pumpingPressureCatch, totalPumpBig, perTotalPumpBig);
+                    pumpingPressureCatch= warnCal(perPoint,  nowPoint,  pumpingWarnValue, sppWarnValue,  pumpingPressureCatch, totalPumpBig, perTotalPumpBig);
                 }
                 Integer calStep = pumpingPressureCatch.getCalStep();
                 if(calStep==1){
@@ -200,7 +202,9 @@ public class PumpingPressureServiceImpl implements PumpingPressureService {
        return isZeroNow && isZeroPer;
     }
 
-    public PumpingPressureCatch warnCal(WellDrilling perPoint, WellDrilling nowPoint, BigDecimal warnValue, BigDecimal warnValueSpp, PumpingPressureCatch pumpingPressureCatch,BigDecimal totalPumpBig,BigDecimal perTotalPumpBig){
+    public PumpingPressureCatch warnCal(WellDrilling perPoint, WellDrilling nowPoint,
+                                        BigDecimal pumpingWarnValue,BigDecimal sppWarnValue,
+                                        PumpingPressureCatch pumpingPressureCatch,BigDecimal totalPumpBig,BigDecimal perTotalPumpBig){
         //未发生变化
         BigDecimal perSpp = perPoint.getSpp().setScale(2, RoundingMode.HALF_UP);
         BigDecimal nowSpp = nowPoint.getSpp().setScale(2, RoundingMode.HALF_UP);
@@ -208,18 +212,18 @@ public class PumpingPressureServiceImpl implements PumpingPressureService {
         boolean isZeroSppPer = perSpp.compareTo(BigDecimal.ZERO) > 0;
         if (isZeroSppNow && isZeroSppPer) {
             log.info("当前点泵压时间:{};参考点泵压时间:{}", nowPoint.getTime(), CommonUtils.removeMilliseconds(perPoint.getTime()));
-            int isBoundaryValue = nowSpp.compareTo(BigDecimal.valueOf(30));
-            if(isBoundaryValue>=0){
-                warnValueSpp=BigDecimal.valueOf(0.05);
-            }else{
-                warnValueSpp=BigDecimal.valueOf(0.1);
-            }
-            Boolean isWarn = sppCalculate(perSpp, nowSpp, warnValueSpp);
+//            int isBoundaryValue = nowSpp.compareTo(BigDecimal.valueOf(30));
+//            if(isBoundaryValue>=0){
+//                warnValueSpp=BigDecimal.valueOf(0.05);
+//            }else{
+//                warnValueSpp=BigDecimal.valueOf(0.1);
+//            }
+            Boolean isWarn = sppCalculate(perSpp, nowSpp, sppWarnValue);
             log.info("是否预警:{}", isWarn ? "是" : "否");
             if (isWarn) {
                 BigDecimal pumpSubtract = totalPumpBig.subtract(perTotalPumpBig).setScale(2,RoundingMode.HALF_UP);
                 BigDecimal sppSubtract = nowSpp.subtract(perSpp).setScale(2,RoundingMode.HALF_UP);
-                pumpingPressureCatch=savePumpingPressureWarnLog(nowPoint,totalPumpBig,perPoint,perTotalPumpBig,pumpingPressureCatch,pumpSubtract,sppSubtract,warnValueSpp.multiply(BigDecimal.valueOf(100)),warnValue.multiply(BigDecimal.valueOf(100)));
+                pumpingPressureCatch=savePumpingPressureWarnLog(nowPoint,totalPumpBig,perPoint,perTotalPumpBig,pumpingPressureCatch,pumpSubtract,sppSubtract,sppWarnValue.multiply(BigDecimal.valueOf(100)),pumpingWarnValue.multiply(BigDecimal.valueOf(100)));
             }else {
                 List<WellDrilling> perPoints = pumpingPressureCatch.getPerPoint();
                 perPoints.remove(0);

yujing-warning-calculation/src/main/java/com/cn/tianji/service/impl/TorqueServiceImpl.java

@@ -240,7 +240,7 @@ public class TorqueServiceImpl implements TorqueService {
         TorqueWarnLog torqueWarnLog=new TorqueWarnLog();
         //判断是否均值预警
         torqueWarnLog = varianceWarn(torqueSampleDataAvg, torqueCatchDataAvg,varianceWarnValue,torqueWarnLog);
-        //判断是否拨动值预警
+        //判断是否波动值预警
         torqueWarnLog = fluctuateWarn(sampleFluctuatedValueSampleData, sampleFluctuatedValueCatchData,fluctuateWarn,torqueWarnLog);
 //        //是否变化量预警
 //        if("1".equals(torqueWarnLog.getIsMeanWarn())){

yujing-warning-calculation/src/main/java/com/cn/tianji/service/impl/TotalPoolVolumeServiceImpl.java

@@ -10,6 +10,7 @@ import com.cn.tianji.common.RedisUtil;
 import com.cn.tianji.entity.TotalPoolVolumeWarnLog;
 import com.cn.tianji.entity.WarnHistory;
 import com.cn.tianji.entity.WellDrilling;
+import com.cn.tianji.entity.YjTotalPoolWarnValue;
 import com.cn.tianji.service.TotalPoolVolumeService;
 import com.cn.tianji.service.TotalPoolVolumeWarnLogService;
 import com.cn.tianji.service.WarnHistoryService;
@@ -28,6 +29,7 @@ import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Date;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * @author Zhao RenJi
@@ -51,7 +53,7 @@ public class TotalPoolVolumeServiceImpl implements TotalPoolVolumeService {
     SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 
     @Override
-    public void totalPoolVolumeWarn(WellDrilling nowPoint, String redisHasKey) throws ParseException {
+    public void totalPoolVolumeWarn(WellDrilling nowPoint, String redisHasKey,List<YjTotalPoolWarnValue> warnValueDatas) throws ParseException {
         String jh=nowPoint.getJh();
         Date nowDate=new Date();
 //        String redisHasKey = jh + "_total_pool_volume";
@@ -77,7 +79,7 @@ public class TotalPoolVolumeServiceImpl implements TotalPoolVolumeService {
         if(isPittotalCatch){
             pittotalCache = JSONObject.toJavaObject(JSONObject.parseObject(JSON.toJSONString(redisUtil.get(redisHasKey))), PittotalCache.class);
             //判断总池体积差值是否超过预警值
-            pittotalCache=warn(nowPittotalBig,nowPoint,pittotalCache);
+            pittotalCache=warn(nowPittotalBig,nowPoint,pittotalCache,warnValueDatas);
             //判断计算时间是否超过5分钟
             long calTimeDiff = CommonUtils.timeDifference(pittotalCache.getStartTime(), sdf.parse(nowPoint.getTime()));
             if(calTimeDiff >= 5 * 60){
@@ -88,7 +90,6 @@ public class TotalPoolVolumeServiceImpl implements TotalPoolVolumeService {
                 pittotalCache.setStartTime(sdf.parse(nowPoint.getTime()));
                 pittotalCache.setReferenceData(referenceData);
                 pittotalCache.setReferenceValue(referenceValueBig);
-
             }
             //判断速率时间是否超过30秒
 //            long rateTimeDiff = CommonUtils.timeDifference(pittotalCache.getRateStartTime(), sdf.parse(nowPoint.getTime()));
@@ -115,7 +116,7 @@ public class TotalPoolVolumeServiceImpl implements TotalPoolVolumeService {
                 pittotalCache.setRateStartTime(sdf.parse(rateData.get(0).getTime()));
                 pittotalCache.setRateStartPittotal(rateData.get(0).getPittotal());
                 pittotalCache.setRateData(rateData);
-                pittotalCache=warn(nowPittotalBig,nowPoint,pittotalCache);
+                pittotalCache=warn(nowPittotalBig,nowPoint,pittotalCache,warnValueDatas);
                 redisUtil.set(redisHasKey, pittotalCache);
             }
         }
@@ -148,7 +149,7 @@ public class TotalPoolVolumeServiceImpl implements TotalPoolVolumeService {
         return wellDrillingService.selectListOrcale(jhTableName, wrapper);
     }
 
-    public PittotalCache warn(BigDecimal nowPittotalBig, WellDrilling nowPoint, PittotalCache pittotalCache) throws ParseException {
+    public PittotalCache warn(BigDecimal nowPittotalBig, WellDrilling nowPoint, PittotalCache pittotalCache,List<YjTotalPoolWarnValue> warnValueDatas) throws ParseException {
         BigDecimal pittotalSub = nowPittotalBig.subtract(pittotalCache.getReferenceValue()).setScale(1, RoundingMode.HALF_UP);
         BigDecimal rantePittotalSub = nowPittotalBig.subtract(pittotalCache.getRateStartPittotal()).setScale(1, RoundingMode.HALF_UP);
         log.info("参考值均值:{};当前点值:{},起点时间:{}",pittotalCache.getReferenceValue(),nowPittotalBig,pittotalCache.getStartTime());
@@ -157,18 +158,24 @@ public class TotalPoolVolumeServiceImpl implements TotalPoolVolumeService {
         //判断预警类被
         //井漏
         if(wanrType<0){
-            int pittotalWarn = pittotalSub.compareTo(BigDecimal.valueOf(-2));
-            int ranteWarn = rantePittotalSub.compareTo(BigDecimal.valueOf(-1));
+            List<YjTotalPoolWarnValue> warnData = warnValueDatas.stream().filter(item -> item.getWarnType().equals("井漏")).collect(Collectors.toList());
+            BigDecimal pittotalWarnValue = warnData.get(0).getPittotalWarn();
+            BigDecimal ranteWarnValue = warnData.get(0).getRanteWarn();
+            int pittotalWarn = pittotalSub.compareTo(pittotalWarnValue);
+            int ranteWarn = rantePittotalSub.compareTo(ranteWarnValue);
             if(pittotalWarn<=0&&ranteWarn<=0){
                 pittotalCache = saveOrUpdateTotalPoolVolumeWarnLog(nowPoint,pittotalCache,"井漏",pittotalSub.setScale(2,RoundingMode.HALF_UP),
-                        rantePittotalSub.setScale(2,RoundingMode.HALF_UP),BigDecimal.valueOf(-2),BigDecimal.valueOf(1),"小于");
+                        rantePittotalSub.setScale(2,RoundingMode.HALF_UP),pittotalWarnValue,ranteWarnValue,"小于");
             }
         }else{ //溢流
-            int pittotalWarn = pittotalSub.compareTo(BigDecimal.valueOf(1));
-            int ranteWarn = rantePittotalSub.compareTo(BigDecimal.valueOf(0.5));
+            List<YjTotalPoolWarnValue> warnData = warnValueDatas.stream().filter(item -> item.getWarnType().equals("溢流")).collect(Collectors.toList());
+            BigDecimal pittotalWarnValue = warnData.get(0).getPittotalWarn();
+            BigDecimal ranteWarnValue = warnData.get(0).getRanteWarn();
+            int pittotalWarn = pittotalSub.compareTo(pittotalWarnValue);
+            int ranteWarn = rantePittotalSub.compareTo(ranteWarnValue);
             if(pittotalWarn>=0&&ranteWarn>=0){
                 pittotalCache = saveOrUpdateTotalPoolVolumeWarnLog(nowPoint,pittotalCache,"溢流",pittotalSub.setScale(2,RoundingMode.HALF_UP),
-                        rantePittotalSub.setScale(2,RoundingMode.HALF_UP),BigDecimal.valueOf(1),BigDecimal.valueOf(0.5),"大于");
+                        rantePittotalSub.setScale(2,RoundingMode.HALF_UP),pittotalWarnValue,ranteWarnValue,"大于");
             }
         }
         return pittotalCache;